yaml-flow 8.7.1 → 8.8.5

package/examples/board/test/server-http-test.js

@@ -6,7 +6,7 @@
  * Targets the 'live' board with --cards-pattern cardT* to load only the 3
  * test cards (cardT-portfolio, cardT-market-prices, cardT-portfolio-value).
  *
- * T0: init-board → SSE initial payload → wait for all cards to complete
+ * T0: /sse streaming connect → upsert fixtures → wait for all cards to complete
  * T1: PATCH holdings (+1 row) → verify recomputation (holdings +1, positions +1)
  *
  * Usage:
@@ -14,7 +14,6 @@
  */
 
 import { spawn, spawnSync } from 'node:child_process';
-import { Worker } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import http from 'node:http';
@@ -45,14 +44,24 @@ function isCopilotAvailable() {
 
 const skipT3a = cliArgs.includes('--skip-t3a') || !isCopilotAvailable();
 const skipT3b = cliArgs.includes('--skip-t3b');
+const skipT3e = cliArgs.includes('--skip-t3e');
 const skipT3d = cliArgs.includes('--skip-t3d');
 const RUN_ID = `run-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
 
 const BOARD_ID = 'live';
 const BOARD_DIR = path.resolve(__dirname, '..');
 const SERVER_SCRIPT = path.resolve(BOARD_DIR, 'server', 'board-server.js');
-const SSE_WORKER_SCRIPT = path.join(__dirname, 'sse-worker.js');
-const CARD_PATTERN = 'cardT*';
+// Force the board server to start with zero cards; the test upserts the
+// three cardT-* fixtures itself in T0 so the SSE upsert/delta path is
+// exercised end-to-end.
+const CARD_PATTERN = '__none__*';
+const CARDS_DIR = path.resolve(BOARD_DIR, 'cards');
+const T0_CARD_FILES = [
+  'cardT-portfolio.json',
+  'cardT-market-prices.json',
+  'cardT-portfolio-value.json',
+];
+const T0_EXPECTED_CARD_IDS = ['card-market-prices', 'card-portfolio', 'card-portfolio-value'];
 const T2_FILE_CARD_ID = 'card-market-prices';
 const CHAT_CARD_ID = 'card-portfolio';
 
@@ -92,19 +101,16 @@ if (fs.existsSync(SETUP_DIR)) {
 // ---------------------------------------------------------------------------
 
 const NS = {
-  initialPayload: null,
   statusSummary: null,
   statusGeneration: 0,
   computedValues: {},
   chatEvents: [],
+  allChatNotifications: [],
   boardEvents: [],
 };
 
 function applyFrame(payload) {
   if (payload && Array.isArray(payload.cardDefinitions)) {
-    if (!NS.initialPayload && payload.cardDefinitions.length > 0) {
-      NS.initialPayload = payload;
-    }
     const summary = payload.statusSnapshot && payload.statusSnapshot.summary;
     if (summary) {
       NS.statusSummary = summary;
@@ -164,6 +170,39 @@ function parseSseBlocks(buffer) {
   return { payloads, remainder: buf };
 }
 
+function parseRawSseBlocks(buffer) {
+  const frames = [];
+  let buf = buffer;
+  while (true) {
+    const idx = buf.indexOf('\n\n');
+    if (idx === -1) break;
+    const block = buf.slice(0, idx);
+    buf = buf.slice(idx + 2);
+    if (!block.trim()) continue;
+    const frame = { id: null, event: null, data: '', payload: null, raw: block };
+    const dataLines = [];
+    for (const line of block.split('\n')) {
+      if (line.startsWith(':')) continue;
+      if (line.startsWith('id:')) {
+        frame.id = line.slice(3).trim();
+      } else if (line.startsWith('event:')) {
+        frame.event = line.slice(6).trim();
+      } else if (line.startsWith('data:')) {
+        dataLines.push(line.slice(5).replace(/^ /, ''));
+      }
+    }
+    frame.data = dataLines.join('\n');
+    if (!frame.id && !frame.event && !frame.data) continue;
+    if (frame.data) {
+      try {
+        frame.payload = JSON.parse(frame.data);
+      } catch { /* ignore malformed */ }
+    }
+    frames.push(frame);
+  }
+  return { frames, remainder: buf };
+}
+
 function startSseClient(sseUrl, onPayload) {
   const req = http.get(sseUrl, (res) => {
     let buf = '';
@@ -183,9 +222,127 @@ function startSseClient(sseUrl, onPayload) {
   };
 }
 
+function startRawSseClient({ sseUrl, headers = {}, onResponse, onFrame, onClose, onError }) {
+  let closed = false;
+  const req = http.request(sseUrl, { headers }, (res) => {
+    let buf = '';
+    res.setEncoding('utf-8');
+    try { onResponse?.(res); } catch { /* ignore */ }
+    res.on('data', (chunk) => {
+      buf = normalizeSseChunkBuffer(buf, chunk);
+      const parsed = parseRawSseBlocks(buf);
+      buf = parsed.remainder;
+      for (const frame of parsed.frames) {
+        try { onFrame?.(frame, res); } catch { /* ignore */ }
+      }
+    });
+    const closeOnce = () => {
+      if (closed) return;
+      closed = true;
+      try { onClose?.(res); } catch { /* ignore */ }
+    };
+    res.on('end', closeOnce);
+    res.on('close', closeOnce);
+    res.on('error', (err) => {
+      try { onError?.(err); } catch { /* ignore */ }
+    });
+  });
+  req.on('error', (err) => {
+    try { onError?.(err); } catch { /* ignore */ }
+  });
+  req.end();
+  return {
+    close() {
+      try { req.destroy(); } catch { /* ignore */ }
+    },
+  };
+}
+
+function waitForRawSseFrames({ sseUrl, headers = {}, until, timeoutMs = 15_000, waitForClose = false }) {
+  return new Promise((resolve, reject) => {
+    const state = { statusCode: null, headers: {}, frames: [], closed: false };
+    let settled = false;
+    let client = null;
+    const predicate = typeof until === 'function' ? until : ((current) => current.frames.length > 0);
+
+    function maybeResolve() {
+      if (settled) return;
+      if (!predicate(state)) return;
+      if (waitForClose && !state.closed) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (!waitForClose && client) client.close();
+      resolve(state);
+    }
+
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      if (client) client.close();
+      reject(new Error(`Timeout (${timeoutMs}ms) waiting for raw SSE frames`));
+    }, timeoutMs);
+
+    client = startRawSseClient({
+      sseUrl,
+      headers,
+      onResponse(res) {
+        state.statusCode = res.statusCode ?? null;
+        state.headers = res.headers || {};
+        maybeResolve();
+      },
+      onFrame(frame) {
+        state.frames.push(frame);
+        maybeResolve();
+      },
+      onClose() {
+        state.closed = true;
+        maybeResolve();
+      },
+      onError(err) {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        reject(err);
+      },
+    });
+  });
+}
+
+function waitForFirstSsePayload(sseUrl, timeoutMs = 15_000) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let client = null;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      if (client) client.close();
+      reject(new Error(`Timeout (${timeoutMs}ms) waiting for: first SSE payload`));
+    }, timeoutMs);
+
+    client = startSseClient(sseUrl, (payload) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      client.close();
+      resolve(payload);
+    });
+  });
+}
+
 function captureChatEvents(payload, cardId) {
   if (!payload || payload.kind !== 'notification-batch' || !Array.isArray(payload.notifications)) return;
   for (const n of payload.notifications) {
+    if (n && n.kind === 'card_chats' && n.cardId) {
+      const messages = Array.isArray(n.messages) ? n.messages : [];
+      NS.allChatNotifications.push({
+        at: Date.now(),
+        cardId: n.cardId,
+        processing: !!n.processing,
+        receiving: !!n.receiving,
+        messageCount: messages.length,
+        messages,
+      });
+    }
     if (n && n.kind === 'card_chats' && n.cardId === cardId) {
       const messages = Array.isArray(n.messages) ? n.messages : [];
       NS.chatEvents.push({
@@ -230,10 +387,159 @@ function waitUntil(predicate, timeoutMs, label) {
   });
 }
 
+function waitUntilAsync(predicate, timeoutMs, label) {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+    const interval = setInterval(async () => {
+      let result;
+      try { result = await predicate(); } catch { /* retry */ }
+      if (result !== undefined && result !== null && result !== false) {
+        clearInterval(interval);
+        resolve(result);
+        return;
+      }
+      if (Date.now() > deadline) {
+        clearInterval(interval);
+        reject(new Error(`Timeout (${timeoutMs}ms) waiting for: ${label}`));
+      }
+    }, 150);
+  });
+}
+
 function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function extractStatusSummaryFromPayload(payload) {
+  if (payload?.statusSnapshot?.summary && typeof payload.statusSnapshot.summary === 'object') {
+    return payload.statusSnapshot.summary;
+  }
+  if (payload?.kind === 'notification-batch' && Array.isArray(payload.notifications)) {
+    for (const notification of payload.notifications) {
+      if (notification?.kind === 'status' && notification.status?.summary && typeof notification.status.summary === 'object') {
+        return notification.status.summary;
+      }
+    }
+  }
+  return null;
+}
+
+function normalizeHydratedChatMessages(messages) {
+  return (Array.isArray(messages) ? messages : []).map((message) => ({
+    role: String(message?.role || ''),
+    text: String(message?.text || ''),
+    files: Array.isArray(message?.files) ? message.files : [],
+  }));
+}
+
+function readHeaderValue(headers, name) {
+  const raw = headers?.[name.toLowerCase()];
+  return Array.isArray(raw) ? String(raw[0] || '') : String(raw || '');
+}
+
+function buildTsStaticCard(cardId, label) {
+  return {
+    id: cardId,
+    meta: {
+      title: label,
+      tags: ['ts', 'sse'],
+      desc: `${label} disposable SSE delta card`,
+    },
+    compute: [],
+    view: {
+      elements: [
+        {
+          kind: 'markdown',
+          data: {
+            bind: 'card_data.text',
+          },
+        },
+      ],
+      layout: {
+        board: {
+          col: 2,
+          order: 99,
+        },
+        canvas: {
+          x: 1600,
+          y: 600,
+          w: 260,
+          h: 120,
+        },
+      },
+      features: {},
+    },
+    card_data: {
+      text: label,
+    },
+  };
+}
+
+function buildChatProbeCard(cardId, label) {
+  return {
+    id: cardId,
+    meta: {
+      title: label,
+      tags: ['chat', 'probe'],
+      desc: `${label} disposable chat probe card`,
+    },
+    provides: [
+      {
+        bindTo: 'holdings',
+        ref: 'card_data.holdings',
+      },
+    ],
+    compute: [],
+    view: {
+      elements: [
+        {
+          kind: 'editable-table',
+          label: 'Holdings',
+          data: {
+            bind: 'card_data.holdings',
+            writeTo: 'card_data.holdings',
+            columns: ['ticker', 'quantity', 'cost_basis'],
+            schema: {
+              properties: {
+                quantity: { type: 'number' },
+                cost_basis: { type: 'number' },
+              },
+            },
+          },
+        },
+      ],
+      layout: {
+        board: {
+          col: 3,
+          order: 98,
+        },
+        canvas: {
+          x: 1400,
+          y: 420,
+          w: 320,
+          h: 260,
+        },
+      },
+      features: {
+        chat: true,
+      },
+    },
+    card_data: {
+      holdings: [
+        { ticker: 'AAPL', quantity: 1, cost_basis: 150 },
+      ],
+    },
+  };
+}
+
+function assertObjectContains(actual, expected, label) {
+  assert(actual && typeof actual === 'object', `${label} actual value is not an object`);
+  assert(expected && typeof expected === 'object', `${label} expected value is not an object`);
+  for (const [key, value] of Object.entries(expected)) {
+    assert(Object.is(actual[key], value), `${label}.${key} mismatch: expected ${JSON.stringify(value)}, got ${JSON.stringify(actual[key])}`);
+  }
+}
+
 async function stopChildProcess(proc, label) {
   if (!proc) return;
   if (proc.exitCode !== null) return;
@@ -267,9 +573,6 @@ async function stopChildProcess(proc, label) {
   }
 }
 
-const waitForInitialPayload = (ms = 15_000) =>
-  waitUntil(() => NS.initialPayload || false, ms, 'initial SSE payload');
-
 const waitForAllCompleted = (ms = 60_000, label = 'all completed') =>
   waitUntil(() => {
     const s = NS.statusSummary;
@@ -315,13 +618,21 @@ function deriveProbeLifecycleMilestones(events, opts) {
 
 function matchOrderedProbeLifecycle(events, opts) {
   const milestones = deriveProbeLifecycleMilestones(events, opts);
-  if (milestones.length !== 5) return false;
-  const firstPair = milestones.slice(0, 2);
-  const lastPair = milestones.slice(3, 5);
-  const firstOk = firstPair.includes('user') && firstPair.includes('processing-true');
-  const middleOk = milestones[2] === 'in-progress';
-  const lastOk = lastPair.includes('assistant') && lastPair.includes('processing-false');
-  return (firstOk && middleOk && lastOk) ? { milestones } : false;
+  const userIdx = milestones.indexOf('user');
+  const processingTrueIdx = milestones.indexOf('processing-true');
+  const assistantIdx = milestones.indexOf('assistant');
+  const processingFalseIdx = milestones.lastIndexOf('processing-false');
+  const inProgressIdx = milestones.indexOf('in-progress');
+
+  if (userIdx === -1 || processingTrueIdx === -1 || assistantIdx === -1 || processingFalseIdx === -1) {
+    return false;
+  }
+
+  if (Math.max(userIdx, processingTrueIdx) >= assistantIdx) return false;
+  if (assistantIdx >= processingFalseIdx) return false;
+  if (inProgressIdx !== -1 && (inProgressIdx <= processingTrueIdx || inProgressIdx >= assistantIdx)) return false;
+
+  return { milestones };
 }
 
 function httpGet(url) {
@@ -502,12 +813,12 @@ console.log(`target: ${BASE}`);
 console.log(`card pattern: ${CARD_PATTERN}`);
 
 const serverProc = await startServer(PORT);
-let sseWorker = null;
+let boardSseClient = null;
 let chatSseClient = null;
 let chatSseClientId = '';
 
 try {
-  // ── T0: init-board, SSE connect, wait for initial completion ──
+  // ── T0: streaming SSE connect, upsert fixtures, wait for initial completion ──
 
   // Register the 'live' board via POST (v8 runtime requires explicit registration)
   const regRes = await httpJson('POST', `http://127.0.0.1:${PORT}/api/boards`, { id: BOARD_ID, label: 'Live' });
@@ -515,31 +826,34 @@ try {
     `POST /api/boards returned ${regRes.status}: ${JSON.stringify(regRes.data)}`);
   console.log(`[setup] board '${BOARD_ID}' registered (${regRes.status})`);
 
-  console.log('\n=== T0 Step 1: init-board ===');
-  const initRes = await httpGet(`${BASE}/init-board`);
-  assert(initRes.status === 200, `init-board returned ${initRes.status}`);
-  console.log('[T0.1] init-board ok');
-
-  console.log('\n=== T0 Step 2: start SSE worker ===');
+  console.log('\n=== T0 Step 1: start SSE client (board expected empty) ===');
   const sseClientId = `server-http-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const sseUrl = `${BASE}/sse?clientId=${encodeURIComponent(sseClientId)}`;
-  sseWorker = new Worker(SSE_WORKER_SCRIPT, {
-    workerData: { sseUrl },
-  });
-  sseWorker.on('message', (msg) => {
-    if (msg.type === 'frame') applyFrame(msg.payload);
-    else if (msg.type === 'error') console.error(`[sse-worker] ${msg.message}`);
-  });
-  sseWorker.on('error', (err) => console.error(`[sse-worker] uncaught: ${err.message}`));
-
-  const initialPayload = await waitForInitialPayload();
-  const cardCount = Array.isArray(initialPayload.cardDefinitions) ? initialPayload.cardDefinitions.length : 0;
-  assert(cardCount === 3, `expected 3 cards (cardT*), got ${cardCount}`);
-  const cardIds = initialPayload.cardDefinitions.map(c => c.id).sort();
-  console.log(`[T0.2] SSE initial payload received (${cardCount} cards: ${cardIds.join(', ')})`);
+  boardSseClient = startSseClient(sseUrl, applyFrame);
+  // Give the streaming endpoint a moment to deliver the initial (empty) snapshot.
+  await wait(500);
+  console.log('[T0.1] SSE client connected');
+
+  console.log('\n=== T0 Step 2: upsert 3 cardT-* fixtures ===');
+  for (const fileName of T0_CARD_FILES) {
+    const cardJson = JSON.parse(fs.readFileSync(path.join(CARDS_DIR, fileName), 'utf-8'));
+    const cardId = cardJson?.id;
+    assert(typeof cardId === 'string' && cardId.length > 0, `fixture ${fileName} missing id`);
+    const upsertRes = await httpMcp('manage.upsert-card', {
+      card_id: cardId,
+      candidate_card_content: cardJson,
+    });
+    assert(upsertRes.status === 200, `manage.upsert-card(${cardId}) returned ${upsertRes.status}: ${JSON.stringify(upsertRes.data)}`);
+    assert(upsertRes.data?.status === 'success', `manage.upsert-card(${cardId}) failed: ${JSON.stringify(upsertRes.data)}`);
+    console.log(`[T0.2] upserted ${cardId}`);
+  }
 
-  console.log('\n=== T0 Step 3: wait for all cards to complete ===');
-  const t0Summary = await waitForAllCompleted(30_000, 'T0 initial completion');
+  console.log('\n=== T0 Step 3: wait for all 3 cards to complete via SSE ===');
+  const t0Summary = await waitUntil(() => {
+    const s = NS.statusSummary;
+    if (s && s.card_count === 3 && s.completed === 3) return s;
+    return false;
+  }, 60_000, 'T0 initial completion (3 cards)');
   assert(t0Summary.failed === 0, `T0 expected failed=0, got ${t0Summary.failed}`);
   console.log(`[T0.3] completed: ${JSON.stringify(t0Summary)}`);
 
@@ -549,6 +863,8 @@ try {
   assert(statusMcpRes.data?.status === 'success', `inspect.board-runtime-status failed: ${JSON.stringify(statusMcpRes.data)}`);
   const mcpSummary = statusMcpRes.data?.data?.summary;
   assert(mcpSummary, 'summary missing from inspect.board-runtime-status');
+  assert(mcpSummary.card_count === T0_EXPECTED_CARD_IDS.length,
+    `expected card_count=${T0_EXPECTED_CARD_IDS.length}, got ${mcpSummary.card_count}`);
   assert(mcpSummary.completed === mcpSummary.card_count, `not all complete: ${JSON.stringify(mcpSummary)}`);
   console.log(`[T0.4] board-status: ${JSON.stringify(mcpSummary)}`);
 
@@ -740,25 +1056,34 @@ try {
 
       const t3TurnId = randomTurnId();
       t3Dbg(`step 4: posting probe chat-send (turn-id=${t3TurnId})`);
-      const t2SendRes = await httpJson('POST', `${BASE}/cards/${CHAT_CARD_ID}/actions`, {
-        actionType: 'chat-send',
-        payload: {
-          text: `${ECHO_PROBE_MARKER}${t2ProbePrompt}${ECHO_PROBE_MARKER}`,
-          'turn-id': t3TurnId,
+      const t2SendRes = await httpJson('POST', `${BASE}/mcp-actions`, {
+        tool: 'chat-send',
+        args: {
+          card_id: CHAT_CARD_ID,
+          payload: {
+            text: `${ECHO_PROBE_MARKER}${t2ProbePrompt}${ECHO_PROBE_MARKER}`,
+            'turn-id': t3TurnId,
+          },
         },
       });
       t3Dbg(`step 4: chat-send returned status=${t2SendRes.status}`);
       assert(t2SendRes.status === 200, `T3 chat-send returned ${t2SendRes.status}`);
 
       t3Dbg('step 5: waiting for ordered probe lifecycle on chat SSE');
-      const t2Lifecycle = await waitForChatPredicate((events) => {
-        return matchOrderedProbeLifecycle(events.slice(t2EventStart), {
-          beforeCount: t2BeforeCount,
-          beforeProcessing: false,
-          prompt: t2ProbePrompt,
-          inProgressText: PROBE_IN_PROGRESS_TEXT,
-        });
-      }, 45_000, 'T3 ordered lifecycle');
+      let t2Lifecycle;
+      try {
+        t2Lifecycle = await waitForChatPredicate((events) => {
+          return matchOrderedProbeLifecycle(events.slice(t2EventStart), {
+            beforeCount: t2BeforeCount,
+            beforeProcessing: false,
+            prompt: t2ProbePrompt,
+            inProgressText: PROBE_IN_PROGRESS_TEXT,
+          });
+        }, 45_000, 'T3 ordered lifecycle');
+      } catch (error) {
+        t3Dbg(`step 5: lifecycle timeout; events=${JSON.stringify(NS.chatEvents.slice(t2EventStart), null, 2)}`);
+        throw error;
+      }
       t3Dbg('step 5: ordered lifecycle observed');
       assert(!!t2Lifecycle, 'T3 ordered lifecycle not observed');
 
@@ -769,12 +1094,12 @@ try {
       const t2AfterMessages = Array.isArray(t2After.data?.data?.messages) ? t2After.data.data.messages : [];
       const t2NewMessages = t2AfterMessages.slice(t2BeforeCount);
       t3Dbg(`step 6: validating ${t2NewMessages.length} new messages`);
-      assert(t2NewMessages.length >= 3, `T3 expected at least 3 new chat messages, got ${t2NewMessages.length}`);
+      assert(t2NewMessages.length >= 2, `T3 expected at least 2 new chat messages, got ${t2NewMessages.length}`);
       const t3McpAfter = await httpMcp('inspect.chat-messages-on-cards', { card_id: CHAT_CARD_ID, turn_id: t3TurnId });
       const t3McpAfterData = expectMcpSuccess(t3McpAfter, 'T3 MCP post chats');
       const t3TurnMessages = Array.isArray(t3McpAfterData?.messages) ? t3McpAfterData.messages : [];
       t3Dbg(`step 6: MCP turn messages count=${t3TurnMessages.length}`);
-      assert(t3TurnMessages.length >= 3, `T3 expected at least 3 MCP messages for turn ${t3TurnId}, got ${t3TurnMessages.length}`);
+      assert(t3TurnMessages.length >= 2, `T3 expected at least 2 MCP messages for turn ${t3TurnId}, got ${t3TurnMessages.length}`);
       for (const msg of t3TurnMessages) {
         assert(String(msg?.turn || '') === t3TurnId, 'T3 MCP turn id mismatch');
       }
@@ -792,7 +1117,6 @@ try {
       const t2AssistantMsg = t2NewMessages.find((m) => m?.role === 'assistant');
       assert(!!t2User && typeof t2User.id === 'string', 'T3 user chat message missing id');
       assert(String(t2User?.text || '').includes(t2ProbePrompt), 'T3 user file text mismatch');
-      assert(!!t2InProgress && typeof t2InProgress.id === 'string', 'T3 in-progress system message missing id');
       assert(!!t2AssistantMsg && typeof t2AssistantMsg.id === 'string', 'T3 assistant chat message missing id');
       assert(String(t2AssistantMsg?.text || '').includes(`Echo: ${t2ProbePrompt}`), 'T3 assistant echo file content mismatch');
       t3Dbg('step 6: all assertions passed');
@@ -818,14 +1142,17 @@ try {
 
     const t3aTurnId = randomTurnId();
     t3aDbg(`step 2: posting non-probe chat-send (turn-id=${t3aTurnId})`);
-    const t2aSendRes = await httpJson('POST', `${BASE}/cards/${CHAT_CARD_ID}/actions`, {
-      actionType: 'chat-send',
-      payload: {
-        text: JSON.stringify({
-          prompt: t2aPrompt,
-          chatTimeoutMs: 180000,
-        }),
-        'turn-id': t3aTurnId,
+    const t2aSendRes = await httpJson('POST', `${BASE}/mcp-actions`, {
+      tool: 'chat-send',
+      args: {
+        card_id: CHAT_CARD_ID,
+        payload: {
+          text: JSON.stringify({
+            prompt: t2aPrompt,
+            chatTimeoutMs: 180000,
+          }),
+          'turn-id': t3aTurnId,
+        },
       },
     });
     t3aDbg(`step 2: chat-send returned status=${t2aSendRes.status}`);
@@ -910,12 +1237,14 @@ try {
     const t2bEventStart = NS.chatEvents.length;
 
     const t2bPrompt = `probe echo file-upload validation ${Date.now()}`;
-    const t2bSendRes = await httpJson('POST', `${BASE}/cards/${CHAT_CARD_ID}/actions`, {
-      actionType: 'chat-send',
-      payload: {
-        text: `${ECHO_PROBE_MARKER}${t2bPrompt}${ECHO_PROBE_MARKER}`,
-        files: [uploadedFile],
-        'turn-id': t3bTurnId,
+    const t2bSendRes = await httpJson('POST', `${BASE}/mcp-actions`, {
+      tool: 'chat-send',
+      args: {
+        card_id: CHAT_CARD_ID,
+        payload: {
+          text: `${ECHO_PROBE_MARKER}${t2bPrompt}${ECHO_PROBE_MARKER}`,
+          'turn-id': t3bTurnId,
+        },
       },
     });
     assert(t2bSendRes.status === 200, `T3b chat-send returned ${t2bSendRes.status}`);
@@ -925,28 +1254,336 @@ try {
         beforeCount: t2bSendBaseline,
         beforeProcessing: false,
         prompt: t2bPrompt,
-        assistantText: 'tokyo',
         inProgressText: PROBE_IN_PROGRESS_TEXT,
       });
-    }, 60_000, 'T3b ordered lifecycle');
+    }, 60_000, 'T3b ordered lifecycle').catch(async (err) => {
+      const t2bEvents = NS.chatEvents.slice(t2bEventStart);
+      const t2bMilestones = deriveProbeLifecycleMilestones(t2bEvents, {
+        beforeCount: t2bSendBaseline,
+        beforeProcessing: false,
+        prompt: t2bPrompt,
+        inProgressText: PROBE_IN_PROGRESS_TEXT,
+      });
+      const t2bCurrent = await httpMcp('inspect.chat-messages-on-cards', { card_id: CHAT_CARD_ID, all_turns: true });
+      console.error('[T3b.DBG timeout] milestones=', JSON.stringify(t2bMilestones));
+      console.error('[T3b.DBG timeout] events=', JSON.stringify(t2bEvents));
+      console.error('[T3b.DBG timeout] inspect=', JSON.stringify(t2bCurrent?.data ?? null));
+      throw err;
+    });
     assert(!!t2bLifecycle, 'T3b ordered lifecycle not observed');
 
     const t2bAfter = await httpMcp('inspect.chat-messages-on-cards', { card_id: CHAT_CARD_ID, all_turns: true });
     assert(t2bAfter.status === 200, `T3b post chats returned ${t2bAfter.status}`);
     const t2bAfterMessages = Array.isArray(t2bAfter.data?.data?.messages) ? t2bAfter.data.data.messages : [];
     const t2bNewMessages = t2bAfterMessages.slice(t2bSendBaseline);
-    assert(t2bNewMessages.length >= 3, `T3b expected at least 3 chat messages after send, got ${t2bNewMessages.length}`);
+    assert(t2bNewMessages.length >= 2, `T3b expected at least 2 chat messages after send, got ${t2bNewMessages.length}`);
 
     const t2bUser = t2bNewMessages.find((m) => m?.role === 'user');
     const t2bInProgress = t2bNewMessages.find((m) => m?.role === 'system' && String(m?.text || '').trim().toLowerCase() === PROBE_IN_PROGRESS_TEXT);
     const t2bAssistantMsg = t2bNewMessages.find((m) => m?.role === 'assistant');
 
     assert(!!t2bUser && typeof t2bUser.id === 'string', 'T3b missing user chat message notification');
-    assert(!!t2bInProgress && typeof t2bInProgress.id === 'string', 'T3b missing in-progress system chat message');
     assert(!!t2bAssistantMsg && typeof t2bAssistantMsg.id === 'string', 'T3b missing assistant chat message notification');
-    assert(Array.isArray(t2bUser?.files) && t2bUser.files.length === 1, 'T3b user chat message missing uploaded file metadata');
-    assert(String(t2bAssistantMsg?.text || '').trim() === 'tokyo', 'T3b assistant attachment content mismatch');
-    console.log('[T3b] ok: upload protocol and ordered probe lifecycle observed with attachment-derived assistant reply');
+    assert(!Array.isArray(t2bUser?.files) || t2bUser.files.length === 0, 'T3b user chat message should remain text-only after add-chat-attachment upload');
+    assert(String(t2bAssistantMsg?.text || '').includes(`Echo: ${t2bPrompt}`), 'T3b assistant probe echo mismatch');
+    console.log('[T3b] ok: add-chat-attachment upload plus text-only chat-send preserved the normal probe lifecycle');
+
+    if (skipT3e) {
+      console.log('\n=== T3e: skipped (--skip-t3e) ===');
+    } else {
+      console.log('\n=== T3e: subscribed chat turn with attachment plus unsubscribed negative case ===');
+      const t3eOtherCardId = `card-t3e-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const t3eOtherCard = buildChatProbeCard(t3eOtherCardId, 'T3e Chat Probe');
+
+      const t3eUpsertOtherRes = await httpMcp('manage.upsert-card', {
+        card_id: t3eOtherCardId,
+        candidate_card_content: t3eOtherCard,
+      });
+      assert(t3eUpsertOtherRes.status === 200, `T3e manage.upsert-card(${t3eOtherCardId}) returned ${t3eUpsertOtherRes.status}`);
+      assert(t3eUpsertOtherRes.data?.status === 'success', `T3e manage.upsert-card(${t3eOtherCardId}) failed: ${JSON.stringify(t3eUpsertOtherRes.data)}`);
+      await waitUntil(() => {
+        const s = NS.statusSummary;
+        if (s && s.card_count === T0_EXPECTED_CARD_IDS.length + 1) return s;
+        return false;
+      }, 30_000, 'T3e extra chat card visible in board summary');
+
+      try {
+        const t3eBefore = await httpMcp('inspect.chat-messages-on-cards', { card_id: CHAT_CARD_ID, all_turns: true });
+        assert(t3eBefore.status === 200, `T3e pre chats returned ${t3eBefore.status}`);
+        const t3eBeforeMessages = Array.isArray(t3eBefore.data?.data?.messages) ? t3eBefore.data.data.messages : [];
+        const t3eBeforeCount = t3eBeforeMessages.length;
+
+        const t3eTurnId = randomTurnId();
+        const t3eUploadRes = await httpMcpControlplane('manage.add-chat-attachment', {
+          board_id: BOARD_ID,
+          card_id: CHAT_CARD_ID,
+          turn_id: t3eTurnId,
+          file_name: 't3e-probe.txt',
+          content_type: 'text/plain; charset=utf-8',
+          text: 'what is the capital of japan',
+        });
+        assert(t3eUploadRes.status === 200, `T3e file upload returned ${t3eUploadRes.status}`);
+        assert(t3eUploadRes.data?.status === 'success', `T3e file upload failed: ${JSON.stringify(t3eUploadRes.data)}`);
+        const t3eUploadedFile = t3eUploadRes.data?.data?.files?.[0];
+        assert(t3eUploadedFile && typeof t3eUploadedFile === 'object', 'T3e upload response missing file metadata');
+        assert(!Object.prototype.hasOwnProperty.call(t3eUploadedFile, 'path'), 'T3e uploaded file metadata should not expose path');
+
+        const t3eCardAfterUpload = await httpMcp('manage.read-card', { card_id: CHAT_CARD_ID });
+        assert(t3eCardAfterUpload.status === 200, `T3e card read after upload returned ${t3eCardAfterUpload.status}`);
+        const t3eStoredFiles = Array.isArray(t3eCardAfterUpload.data?.data?.[0]?.card_data?.files)
+          ? t3eCardAfterUpload.data.data[0].card_data.files
+          : [];
+        const t3eStoredFile = t3eStoredFiles.find((file) => String(file?.stored_name || '') === String(t3eUploadedFile?.stored_name || ''));
+        assert(!!t3eStoredFile, 'T3e stored file metadata missing after upload');
+        assert(t3eStoredFile?.chat === true, 'T3e stored file should be marked as chat-origin');
+        assert(!Object.prototype.hasOwnProperty.call(t3eStoredFile || {}, 'path'), 'T3e stored file metadata should not expose path');
+
+        const t3eUploadMessages = await httpMcp('inspect.chat-messages-on-cards', { card_id: CHAT_CARD_ID, turn_id: t3eTurnId });
+        assert(t3eUploadMessages.status === 200, `T3e chats after upload returned ${t3eUploadMessages.status}`);
+        const t3eUploadTurnMessages = Array.isArray(t3eUploadMessages.data?.data?.messages) ? t3eUploadMessages.data.data.messages : [];
+        const t3eUploadSystem = t3eUploadTurnMessages.find((message) => message?.role === 'system');
+        assert(!!t3eUploadSystem, 'T3e upload protocol missing system chat message');
+        assert(String(t3eUploadSystem?.text || '').toLowerCase().includes('file uploaded:'), 'T3e upload system message does not describe uploaded file');
+
+        const t3eEventStart = NS.chatEvents.length;
+        const t3eAllNotificationsStart = NS.allChatNotifications.length;
+        const t3ePrompt = `attachment probe ${Date.now()}`;
+        const t3eProbeText = `${ECHO_PROBE_MARKER}${t3ePrompt}${ECHO_PROBE_MARKER}`;
+        const t3eSendRes = await httpJson('POST', `${BASE}/mcp-actions`, {
+          tool: 'chat-send',
+          args: {
+            card_id: CHAT_CARD_ID,
+            payload: {
+              text: t3eProbeText,
+              'turn-id': t3eTurnId,
+            },
+          },
+        });
+        assert(t3eSendRes.status === 200, `T3e chat-send returned ${t3eSendRes.status}`);
+
+        const t3eLifecycle = await waitForChatPredicate((events) => {
+          return matchOrderedProbeLifecycle(events.slice(t3eEventStart), {
+            beforeCount: t3eBeforeCount + t3eUploadTurnMessages.length,
+            beforeProcessing: false,
+            prompt: t3ePrompt,
+            inProgressText: PROBE_IN_PROGRESS_TEXT,
+          });
+        }, 60_000, 'T3e ordered lifecycle');
+        assert(!!t3eLifecycle, 'T3e ordered lifecycle not observed');
+
+        const t3eAfter = await httpMcp('inspect.chat-messages-on-cards', { card_id: CHAT_CARD_ID, turn_id: t3eTurnId });
+        assert(t3eAfter.status === 200, `T3e post chats returned ${t3eAfter.status}`);
+        const t3eFinalMessages = Array.isArray(t3eAfter.data?.data?.messages) ? t3eAfter.data.data.messages : [];
+        const t3eFinalUser = t3eFinalMessages.find((message) => message?.role === 'user');
+        const t3eFinalAssistant = t3eFinalMessages.find((message) => message?.role === 'assistant');
+        assert(!!t3eFinalUser, `T3e final user message missing: ${JSON.stringify(t3eFinalMessages)}`);
+        assert(!!t3eFinalAssistant, `T3e final assistant message missing: ${JSON.stringify(t3eFinalMessages)}`);
+        assert(String(t3eFinalUser?.text || '') === t3ePrompt, `T3e final user text mismatch: ${JSON.stringify(t3eFinalUser)}`);
+        assert(!Array.isArray(t3eFinalUser?.files) || t3eFinalUser.files.length === 0,
+          `T3e final user message should remain text-only after controlplane attachment upload: ${JSON.stringify(t3eFinalUser)}`);
+        assert(String(t3eFinalAssistant?.text || '').includes(`Echo: ${t3ePrompt}`), `T3e final probe reply mismatch: ${JSON.stringify(t3eFinalAssistant)}`);
+
+        const t3eNegativeTurnId = randomTurnId();
+        const t3eNegativeSendRes = await httpJson('POST', `${BASE}/mcp-actions`, {
+          tool: 'chat-send',
+          args: {
+            card_id: t3eOtherCardId,
+            payload: {
+              text: `${ECHO_PROBE_MARKER}negative unsubscribed ${Date.now()}${ECHO_PROBE_MARKER}`,
+              'turn-id': t3eNegativeTurnId,
+            },
+          },
+        });
+        assert(t3eNegativeSendRes.status === 200, `T3e negative chat-send returned ${t3eNegativeSendRes.status}`);
+
+        const t3eNegativePersisted = await waitUntilAsync(async () => {
+          const result = await httpMcp('inspect.chat-messages-on-cards', { card_id: t3eOtherCardId, turn_id: t3eNegativeTurnId });
+          if (result.status !== 200) return false;
+          const messages = Array.isArray(result.data?.data?.messages) ? result.data.data.messages : [];
+          return messages.find((message) => message?.role === 'assistant') ? messages : false;
+        }, 60_000, 'T3e negative turn persisted on unsubscribed card');
+        assert(Array.isArray(t3eNegativePersisted), 'T3e negative turn did not persist as expected');
+
+        await wait(1_500);
+        const t3eUnexpectedNotification = NS.allChatNotifications.slice(t3eAllNotificationsStart)
+          .find((event) => event?.cardId === t3eOtherCardId);
+        assert(!t3eUnexpectedNotification,
+          `T3e unsubscribed client unexpectedly received chat notification for ${t3eOtherCardId}: ${JSON.stringify(t3eUnexpectedNotification)}`);
+
+        console.log('[T3e] ok: subscribed client received attachment-bearing turn and unsubscribed card produced no chat SSE notification');
+      } finally {
+        const t3eRemoveOtherRes = await httpMcp('manage.remove-card', { card_id: t3eOtherCardId });
+        assert(t3eRemoveOtherRes.status === 200, `T3e manage.remove-card(${t3eOtherCardId}) returned ${t3eRemoveOtherRes.status}`);
+        assert(t3eRemoveOtherRes.data?.status === 'success', `T3e manage.remove-card(${t3eOtherCardId}) failed: ${JSON.stringify(t3eRemoveOtherRes.data)}`);
+        await waitUntil(() => {
+          const s = NS.statusSummary;
+          if (s && s.card_count === T0_EXPECTED_CARD_IDS.length) return s;
+          return false;
+        }, 30_000, 'T3e cleanup card_count back to 3');
+      }
+    }
+
+    console.log('\n=== T3c: fresh /sse connect hydrates current board state ===');
+    const t3cInspectStatusRes = await httpMcp('inspect.board-runtime-status', {});
+    assert(t3cInspectStatusRes.status === 200, `T3c inspect.board-runtime-status returned ${t3cInspectStatusRes.status}`);
+    assert(t3cInspectStatusRes.data?.status === 'success', `T3c inspect.board-runtime-status failed: ${JSON.stringify(t3cInspectStatusRes.data)}`);
+    const t3cExpectedSummary = t3cInspectStatusRes.data?.data?.summary;
+    assert(t3cExpectedSummary, 'T3c summary missing from inspect.board-runtime-status');
+
+    const t3cExpectedCards = {};
+    for (const cardId of T0_EXPECTED_CARD_IDS) {
+      const t3cInspectCardRes = await httpMcp('inspect.card-definition-and-runtime', { card_id: cardId });
+      assert(t3cInspectCardRes.status === 200, `T3c inspect.card-definition-and-runtime(${cardId}) returned ${t3cInspectCardRes.status}`);
+      assert(t3cInspectCardRes.data?.status === 'success', `T3c inspect.card-definition-and-runtime(${cardId}) failed: ${JSON.stringify(t3cInspectCardRes.data)}`);
+      const t3cInspectCardData = t3cInspectCardRes.data?.data;
+      assert(t3cInspectCardData && typeof t3cInspectCardData === 'object', `T3c inspect.card-definition-and-runtime(${cardId}) missing data`);
+      t3cExpectedCards[cardId] = t3cInspectCardData;
+    }
+
+    const t3cRefreshClientId = `server-http-refresh-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const t3cRefreshPayload = await waitForFirstSsePayload(`${BASE}/sse?clientId=${encodeURIComponent(t3cRefreshClientId)}`);
+    assert(t3cRefreshPayload && typeof t3cRefreshPayload === 'object', 'T3c missing refresh SSE payload');
+
+    const t3cCardDefinitions = Array.isArray(t3cRefreshPayload.cardDefinitions) ? t3cRefreshPayload.cardDefinitions : [];
+    const t3cCardIds = t3cCardDefinitions.map((card) => card?.id).filter((id) => typeof id === 'string').sort();
+    assert(JSON.stringify(t3cCardIds) === JSON.stringify(T0_EXPECTED_CARD_IDS),
+      `T3c refreshed SSE cardDefinitions mismatch: ${JSON.stringify(t3cCardIds)}`);
+
+    const t3cStatusSummary = t3cRefreshPayload.statusSnapshot?.summary;
+    assert(t3cStatusSummary, 'T3c refresh SSE payload missing statusSnapshot.summary');
+    assertObjectContains(t3cStatusSummary, t3cExpectedSummary, 'T3c refresh SSE summary');
+
+    const t3cCardRuntimeById = t3cRefreshPayload.cardRuntimeById && typeof t3cRefreshPayload.cardRuntimeById === 'object'
+      ? t3cRefreshPayload.cardRuntimeById
+      : {};
+    for (const card of t3cCardDefinitions) {
+      const cardId = card?.id;
+      if (typeof cardId !== 'string' || !t3cExpectedCards[cardId]) continue;
+      const t3cExpectedCard = t3cExpectedCards[cardId];
+      assert(JSON.stringify(card) === JSON.stringify(t3cExpectedCard.card_definition_and_static_data),
+        `T3c refresh SSE cardDefinitions[${cardId}] mismatch`);
+
+      const t3cHydratedCardRuntime = t3cCardRuntimeById[cardId];
+      assert(t3cHydratedCardRuntime && typeof t3cHydratedCardRuntime === 'object', `T3c refresh SSE payload missing cardRuntimeById.${cardId}`);
+      assert(JSON.stringify(t3cHydratedCardRuntime.card_data || {}) === JSON.stringify(t3cExpectedCard.card_definition_and_static_data?.card_data || {}),
+        `T3c refresh SSE cardRuntimeById.${cardId}.card_data mismatch`);
+      assert(JSON.stringify(t3cHydratedCardRuntime.computed_values || {}) === JSON.stringify(t3cExpectedCard.runtime_data?.computed_values || {}),
+        `T3c refresh SSE cardRuntimeById.${cardId}.computed_values mismatch`);
+    }
+    console.log('[T3c] ok: fresh /sse first payload hydrated the current board state');
+
+    console.log('\n=== TS: one-shot, raw framing, replay, delta ordering, and chat hydration ===');
+    const tsExpectedChatRes = await httpMcp('inspect.chat-messages-on-cards', { card_id: CHAT_CARD_ID, all_turns: true });
+    assert(tsExpectedChatRes.status === 200, `TS inspect.chat-messages-on-cards returned ${tsExpectedChatRes.status}`);
+    const tsExpectedChatMessages = normalizeHydratedChatMessages(tsExpectedChatRes.data?.data?.messages || []);
+
+    const tsOneShot = await waitForRawSseFrames({
+      sseUrl: `${BASE}/sse?one-shot`,
+      timeoutMs: 15_000,
+      until: (state) => state.frames.length >= 1,
+      waitForClose: true,
+    });
+    assert(tsOneShot.statusCode === 200, `TS one-shot returned ${tsOneShot.statusCode}`);
+    assert(/text\/event-stream/i.test(readHeaderValue(tsOneShot.headers, 'content-type')),
+      `TS one-shot content-type mismatch: ${readHeaderValue(tsOneShot.headers, 'content-type')}`);
+    assert(tsOneShot.closed === true, 'TS one-shot connection should close after first frame');
+    assert(tsOneShot.frames.length === 1, `TS one-shot expected exactly 1 frame, got ${tsOneShot.frames.length}`);
+    const tsOneShotFrame = tsOneShot.frames[0];
+    assert(/^\d+$/.test(String(tsOneShotFrame.id || '')), `TS one-shot frame missing numeric id: ${JSON.stringify(tsOneShotFrame)}`);
+    assert(tsOneShotFrame.payload && typeof tsOneShotFrame.payload === 'object', 'TS one-shot frame missing JSON payload');
+    const tsOneShotChatState = tsOneShotFrame.payload.cardChatsByCardId?.[CHAT_CARD_ID];
+    assert(tsOneShotChatState && typeof tsOneShotChatState === 'object', `TS one-shot payload missing cardChatsByCardId.${CHAT_CARD_ID}`);
+    assert(JSON.stringify(normalizeHydratedChatMessages(tsOneShotChatState.messages)) === JSON.stringify(tsExpectedChatMessages),
+      'TS one-shot cardChatsByCardId hydration mismatch');
+
+    const tsDeltaClientId = `ts-delta-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const tsRawFrames = [];
+    const tsDeltaClient = startRawSseClient({
+      sseUrl: `${BASE}/sse?clientId=${encodeURIComponent(tsDeltaClientId)}`,
+      onFrame(frame) {
+        tsRawFrames.push(frame);
+      },
+    });
+
+    try {
+      const tsInitialFrame = await waitUntil(() => tsRawFrames[0] || false, 15_000, 'TS initial raw SSE frame');
+      assert(/^\d+$/.test(String(tsInitialFrame.id || '')), `TS initial streaming frame missing numeric id: ${JSON.stringify(tsInitialFrame)}`);
+      const tsInitialChatState = tsInitialFrame.payload?.cardChatsByCardId?.[CHAT_CARD_ID];
+      assert(tsInitialChatState && typeof tsInitialChatState === 'object', `TS initial streaming payload missing cardChatsByCardId.${CHAT_CARD_ID}`);
+      assert(JSON.stringify(normalizeHydratedChatMessages(tsInitialChatState.messages)) === JSON.stringify(tsExpectedChatMessages),
+        'TS initial streaming cardChatsByCardId hydration mismatch');
+
+      const tsTempCards = [
+        buildTsStaticCard(`card-ts-${Date.now()}-a`, 'TS Delta Card A'),
+        buildTsStaticCard(`card-ts-${Date.now()}-b`, 'TS Delta Card B'),
+      ];
+      let tsLastEventId = Number(tsInitialFrame.id);
+
+      for (let idx = 0; idx < tsTempCards.length; idx += 1) {
+        const tsCard = tsTempCards[idx];
+        const tsExpectedCardCount = T0_EXPECTED_CARD_IDS.length + idx + 1;
+        const tsFrameStart = tsRawFrames.length;
+        const tsUpsertRes = await httpMcp('manage.upsert-card', {
+          card_id: tsCard.id,
+          candidate_card_content: tsCard,
+        });
+        assert(tsUpsertRes.status === 200, `TS manage.upsert-card(${tsCard.id}) returned ${tsUpsertRes.status}`);
+        assert(tsUpsertRes.data?.status === 'success', `TS manage.upsert-card(${tsCard.id}) failed: ${JSON.stringify(tsUpsertRes.data)}`);
+        const tsDeltaFrame = await waitUntil(() => {
+          for (const frame of tsRawFrames.slice(tsFrameStart)) {
+            const summary = extractStatusSummaryFromPayload(frame.payload);
+            if (summary?.card_count === tsExpectedCardCount) return frame;
+          }
+          return false;
+        }, 30_000, `TS board delta card_count=${tsExpectedCardCount}`);
+        assert(Number(tsDeltaFrame.id) > tsLastEventId,
+          `TS delta frame id did not increase: prev=${tsLastEventId}, next=${JSON.stringify(tsDeltaFrame.id)}`);
+        tsLastEventId = Number(tsDeltaFrame.id);
+      }
+
+      tsDeltaClient.close();
+      await wait(250);
+
+      const tsReconnect = await waitForRawSseFrames({
+        sseUrl: `${BASE}/sse?clientId=${encodeURIComponent(tsDeltaClientId)}`,
+        headers: { 'Last-Event-ID': String(tsLastEventId) },
+        timeoutMs: 15_000,
+        until: (state) => state.frames.length >= 1,
+      });
+      assert(tsReconnect.statusCode === 200, `TS reconnect returned ${tsReconnect.statusCode}`);
+      assert(/text\/event-stream/i.test(readHeaderValue(tsReconnect.headers, 'content-type')),
+        `TS reconnect content-type mismatch: ${readHeaderValue(tsReconnect.headers, 'content-type')}`);
+      const tsReconnectFrame = tsReconnect.frames[0];
+      assert(Number(tsReconnectFrame.id) > tsLastEventId,
+        `TS reconnect frame id did not advance beyond Last-Event-ID: prev=${tsLastEventId}, next=${JSON.stringify(tsReconnectFrame.id)}`);
+      const tsReconnectPayload = tsReconnectFrame.payload;
+      assert(tsReconnectPayload && typeof tsReconnectPayload === 'object', 'TS reconnect first frame missing JSON payload');
+      const tsReconnectIds = (Array.isArray(tsReconnectPayload.cardDefinitions) ? tsReconnectPayload.cardDefinitions : [])
+        .map((card) => card?.id)
+        .filter((cardId) => typeof cardId === 'string')
+        .sort();
+      const tsExpectedReconnectIds = [...T0_EXPECTED_CARD_IDS, ...tsTempCards.map((card) => card.id)].sort();
+      assert(JSON.stringify(tsReconnectIds) === JSON.stringify(tsExpectedReconnectIds),
+        `TS reconnect snapshot mismatch: expected ${JSON.stringify(tsExpectedReconnectIds)}, got ${JSON.stringify(tsReconnectIds)}`);
+      const tsReconnectChatState = tsReconnectPayload.cardChatsByCardId?.[CHAT_CARD_ID];
+      assert(tsReconnectChatState && typeof tsReconnectChatState === 'object', `TS reconnect payload missing cardChatsByCardId.${CHAT_CARD_ID}`);
+      assert(JSON.stringify(normalizeHydratedChatMessages(tsReconnectChatState.messages)) === JSON.stringify(tsExpectedChatMessages),
+        'TS reconnect cardChatsByCardId hydration mismatch');
+
+      for (const tsCard of tsTempCards) {
+        const tsRemoveRes = await httpMcp('manage.remove-card', { card_id: tsCard.id });
+        assert(tsRemoveRes.status === 200, `TS manage.remove-card(${tsCard.id}) returned ${tsRemoveRes.status}`);
+        assert(tsRemoveRes.data?.status === 'success', `TS manage.remove-card(${tsCard.id}) failed: ${JSON.stringify(tsRemoveRes.data)}`);
+      }
+      await waitUntil(() => {
+        const summary = NS.statusSummary;
+        if (summary && summary.card_count === T0_EXPECTED_CARD_IDS.length) return summary;
+        return false;
+      }, 30_000, 'TS cleanup card_count back to 3');
+    } finally {
+      tsDeltaClient.close();
+    }
+    console.log('[TS] ok: one-shot framing, event ids, Last-Event-ID reconnect, ordered board deltas, and initial chat hydration verified');
   }
 
   // ── T3d: probe-echo chat with one AI-generated attachment ──
@@ -982,11 +1619,14 @@ try {
     const t3dTurnId = randomTurnId();
     const t2dPrompt = `probe generated attachment validation ${Date.now()}`;
     const t2dEventStart = NS.chatEvents.length;
-    const t2dSendRes = await httpJson('POST', `${BASE}/cards/${CHAT_CARD_ID}/actions`, {
-      actionType: 'chat-send',
-      payload: {
-        text: `${ECHO_PROBE_MARKER}[attach] ${t2dPrompt}${ECHO_PROBE_MARKER}`,
-        'turn-id': t3dTurnId,
+    const t2dSendRes = await httpJson('POST', `${BASE}/mcp-actions`, {
+      tool: 'chat-send',
+      args: {
+        card_id: CHAT_CARD_ID,
+        payload: {
+          text: `${ECHO_PROBE_MARKER}echoattach__ ${t2dPrompt}${ECHO_PROBE_MARKER}`,
+          'turn-id': t3dTurnId,
+        },
       },
     });
     assert(t2dSendRes.status === 200, `T3d chat-send returned ${t2dSendRes.status}`);
@@ -1006,7 +1646,7 @@ try {
     assert(t2dAfter.status === 200, `T3d post chats returned ${t2dAfter.status}`);
     const t2dAfterMessages = Array.isArray(t2dAfter.data?.data?.messages) ? t2dAfter.data.data.messages : [];
     const t2dNewMessages = t2dAfterMessages.slice(t2dBeforeCount);
-    assert(t2dNewMessages.length >= 4, `T3d expected at least 4 chat messages after send, got ${t2dNewMessages.length}`);
+    assert(t2dNewMessages.length >= 3, `T3d expected at least 3 chat messages after send, got ${t2dNewMessages.length}`);
 
     const t2dUser = t2dNewMessages.find((m) => m?.role === 'user');
     const t2dInProgress = t2dNewMessages.find((m) => m?.role === 'system' && String(m?.text || '').trim().toLowerCase() === PROBE_IN_PROGRESS_TEXT);
@@ -1014,7 +1654,6 @@ try {
     const t2dAssistantMsg = t2dNewMessages.find((m) => m?.role === 'assistant');
 
     assert(!!t2dUser && typeof t2dUser.id === 'string', 'T3d missing user chat message');
-    assert(!!t2dInProgress && typeof t2dInProgress.id === 'string', 'T3d missing in-progress system chat message');
     assert(!!t2dAiGenerated && typeof t2dAiGenerated.id === 'string', 'T3d missing AI-generated attachment system chat message');
     assert(/#\d+\s*$/.test(String(t2dAiGenerated?.text || '')), 'T3d AI-generated system message should include merged file index');
     assert(String(t2dAiGenerated?.turn || '') === t3dTurnId, 'T3d AI-generated system turn id mismatch');
@@ -1643,8 +2282,8 @@ try {
     } catch { /* ignore */ }
   }
   if (chatSseClient) chatSseClient.close();
+  if (boardSseClient) boardSseClient.close();
   await stopChildProcess(serverProc, 'demo board server');
-  if (sseWorker) await sseWorker.terminate();
 
   // Clean up the test setup directory
   if (fs.existsSync(SETUP_DIR)) {