@sanqianx/claude-ai-workbench 0.13.5 → 0.13.6

package/apps/agent-terminal/app.js

@@ -1063,6 +1063,21 @@ function renderHistoryBar() {
 
 function historyEventKey(event) { return JSON.stringify([event.type, event.id || '', event.sequence || 0, event.at || '', event.text || '']); }
 
+function mergeHistoryEvents(fetched, buffered) {
+  const keys = new Set(fetched.map(historyEventKey));
+  const sequences = new Set(fetched.map(event => Number(event.sequence)).filter(sequence => sequence > 0));
+  const compacted = fetched.filter(event => Number(event.compactFrom) > 0);
+  const queued = buffered.filter(event => {
+    if (keys.has(historyEventKey(event))) return false;
+    const sequence = Number(event.sequence);
+    if (!(sequence > 0)) return true;
+    if (sequences.has(sequence)) return false;
+    return !compacted.some(row => row.type === event.type && row.id === event.id
+      && row.parentToolUseId === event.parentToolUseId && sequence >= Number(row.compactFrom) && sequence <= Number(row.sequence));
+  });
+  return [...fetched, ...queued].sort((a, b) => (Number(a.sequence) || 0) - (Number(b.sequence) || 0));
+}
+
 function rebuildHistory(view, events, prepend = true) {
   const stream = $('stream');
   const top = stream.scrollTop, height = stream.scrollHeight, following = state.follow, intent = state.scrollIntent;
@@ -1104,7 +1119,7 @@ async function loadEarlierHistory() {
     view.nextCursor = page.nextCursor;
     view.incomplete = page.incomplete;
     view.error = false;
-    rebuildHistory(view, [...page.events, ...view.events]);
+    rebuildHistory(view, mergeHistoryEvents(page.events, view.events));
   } catch { if (historyView === view) view.error = true; }
   finally { if (historyView === view && revision === view.revision) { view.loading = false; renderHistoryBar(); } }
 }
@@ -1135,10 +1150,8 @@ async function reloadHistory(view) {
     // (including before this reload even started) survive unless the fetched
     // history already contains them. The fetched page must never overwrite
     // the live tail into silence.
-    const fetchedKeys = new Set(events.map(historyEventKey));
-    const queued = buffered.filter(event => !fetchedKeys.has(historyEventKey(event)));
     view.nextCursor = nextCursor; view.incomplete = page.incomplete; view.error = false;
-    rebuildHistory(view, [...events, ...queued], false);
+    rebuildHistory(view, mergeHistoryEvents(events, buffered), false);
   } catch { if (historyView === view) view.error = true; }
   finally { if (historyView === view && revision === view.revision) { view.loading = false; renderHistoryBar(); } }
 }
@@ -1180,6 +1193,8 @@ function resetStream() {
   const col = $('stream-col');
   col.textContent = '';
   turn = null;
+  pendingReplyGroups.length = 0;
+  replyGroup = null;
   state.completedReply = null;
   state.follow = true;
   state.scrollIntent = null;
@@ -1248,8 +1263,22 @@ function checkMark() {
 // single collapsible block headed by the running/elapsed timer, ZCode-style
 // (工作中 X 秒 → 已工作 X 秒); only the final message stays in the open stream.
 let turn = null;
+const pendingReplyGroups = [];
+let replyGroup = null;
+
+function newReplyGroup(turnId) {
+  const group = { turnId: turnId || null, before: null, completedReply: null, context: null };
+  pendingReplyGroups.push(group);
+  return group;
+}
 
-function startTurn() {
+function appendReply(node, group) {
+  const col = $('stream-col');
+  if (group?.before?.isConnected) col.insertBefore(node, group.before);
+  else col.append(node);
+}
+
+function startTurn(turnId) {
   endTurnVisuals();
   turn = {
     startedAt: Date.now(), timerId: null, proc: null, steps: null, meta: null,
@@ -1257,6 +1286,10 @@ function startTurn() {
     lastPrompt: '', changes: new Map(), interrupted: false,
     stderrNote: null, stderrLast: '', thinkHint: null, lastError: '',
   };
+  if (!replyGroup || !pendingReplyGroups.includes(replyGroup)) replyGroup = newReplyGroup(turnId);
+  turn.replyGroup = replyGroup;
+  replyGroup.completedReply = null;
+  replyGroup.context = turn;
   return turn;
 }
 
@@ -1316,6 +1349,7 @@ function showThinkingHint(t) {
 function endTurnVisuals(durationMs) {
   const t = turn;
   if (!t) return;
+  if (t.liveText?.isConnected && t.replyGroup) t.replyGroup.completedReply = { node: t.liveText, text: t.liveRaw || '' };
   stampThinking(t);
   hideThinkingHint(t);
   if (t.timerId) { clearInterval(t.timerId); t.timerId = null; }
@@ -1529,14 +1563,16 @@ function renderEvent(event) {
         wrap.append(tray);
       }
       col.append(wrap);
-      const ctx = startTurn();
+      for (const group of pendingReplyGroups) if (!group.before) group.before = wrap;
+      replyGroup = newReplyGroup(event.turnId);
+      const ctx = startTurn(event.turnId);
       ctx.lastPrompt = event.text || '';
       break;
     }
     case 'claude/text-start':
     case 'claude/text-delta': {
       stampThinking(t);
-      const ctx = t || startTurn();
+      const ctx = t || startTurn(event.turnId);
       if (!ctx.liveText || !ctx.liveText.isConnected) {
         const msg = buildConversationMessage('assistant', '');
         const body = msg.querySelector('.md-body');
@@ -1557,7 +1593,7 @@ function renderEvent(event) {
       break;
     }
     case 'claude/thinking-start': {
-      const ctx = ensureProc(t || startTurn());
+      const ctx = ensureProc(t || startTurn(event.turnId));
       stampThinking(ctx);
       const seg = el('div', 'think-seg');
       seg._startedAt = Date.now();
@@ -1578,7 +1614,7 @@ function renderEvent(event) {
       break;
     case 'claude/tool-use': {
       stampThinking(t);
-      const ctx = ensureProc(t || startTurn());
+      const ctx = ensureProc(t || startTurn(event.turnId));
       const input = event.input || {};
       ctx.steps.append(buildToolStep(event, input));
       break;
@@ -1632,32 +1668,41 @@ function renderEvent(event) {
       refreshContextUsage();
       break;
     case 'claude/turn-end':
+      if (event.boundary === 'result') break; // result already finalized its own response
+      if (event.turnId && replyGroup?.turnId && event.turnId !== replyGroup.turnId) break;
       if (t?.liveText?.isConnected) state.completedReply = { node: t.liveText, text: t.liveRaw || '' };
       endTurnVisuals();
       setBusyState(event.exitCode ? 'failed' : 'idle');
       break;
     case 'claude/result': {
-      stampThinking(t);
-      const hadLiveText = Boolean(t?.liveText?.isConnected || state.completedReply?.node?.isConnected && String(state.completedReply.text).trim() === String(event.result || '').trim());
-      const lastPrompt = t ? t.lastPrompt : '';
-      const turnChanges = t ? t.changes : null;
+      const index = event.turnId ? pendingReplyGroups.findIndex(group => group.turnId === event.turnId) : 0;
+      if (event.turnId && index < 0) break; // an earlier response may be outside the currently loaded history page
+      const group = pendingReplyGroups.splice(index, 1)[0] || replyGroup;
+      const owner = group?.context || t;
+      const current = !group || group === replyGroup;
+      stampThinking(owner);
+      const hadLiveText = Boolean(owner?.liveText?.isConnected || group?.completedReply?.node?.isConnected);
+      const lastPrompt = owner ? owner.lastPrompt : '';
+      const turnChanges = owner ? owner.changes : null;
       const turnModel = event.model || (state.sessionSummary && state.sessionSummary.model) || '';
-      endTurnVisuals(event.durationMs != null ? event.durationMs : event.duration_ms);
+      if (t === owner) endTurnVisuals(event.durationMs != null ? event.durationMs : event.duration_ms);
+      let replyNode = owner?.liveText?.isConnected ? owner.liveText : group?.completedReply?.node;
       if (event.isError) {
         const err = el('div', 'msg ai');
         const dim = el('p', 'dim');
         dim.append(icon('warn', 13), el('span', null, ` ${event.result || event.message || '执行出错'}`));
         err.append(dim);
-        col.append(err);
+        appendReply(err, group);
       } else {
         if (!hadLiveText && event.result) {
-          col.append(buildConversationMessage('assistant', String(event.result)));
+          replyNode = buildConversationMessage('assistant', String(event.result));
+          appendReply(replyNode, group);
         }
-        const lastMsg = [...col.children].reverse().find(node => node.classList && node.classList.contains('ai'));
+        const lastMsg = replyNode;
         if (lastMsg) lastMsg.append(msgFooter(String(event.result || lastMsg.textContent), lastPrompt, { model: turnModel, at: event.at }));
-        if (turnChanges && turnChanges.size) col.append(renderTurnDiffs(turnChanges));
+        if (turnChanges && turnChanges.size) appendReply(renderTurnDiffs(turnChanges), group);
       }
-      setBusyState('idle');
+      if (current) setBusyState('idle');
       refreshContextUsage();
       if (!state.replaying) refreshSessionRow();
       break;
@@ -1677,6 +1722,7 @@ function renderEvent(event) {
     case 'claude/aborted':
       if (t) t.interrupted = true;
       endTurnVisuals();
+      pendingReplyGroups.length = 0; replyGroup = null;
       {
         const stopNote = el('div', 'turn-note');
         stopNote.append(icon('stop', 12), el('span', null, ` ${abortStopLabel(event.reason)}`));
@@ -1694,6 +1740,7 @@ function renderEvent(event) {
     case 'claude/error': {
       const message = String(event.message || event.error || '执行出错');
       endTurnVisuals();
+      pendingReplyGroups.length = 0; replyGroup = null;
       const err = el('div', 'msg ai error');
       err.append(icon('warn', 15), el('span', 'err-text', message));
       col.append(err);

package/apps/agent-terminal/right-workspace-dock.css

@@ -116,6 +116,8 @@
 
 .rd-error { padding: 4px 10px; color: var(--bad); font-size: 12px; flex: 0 0 auto; white-space: pre-wrap; }
 .rd-error[hidden] { display: none; }
+.rd-retry { margin-left: 10px; padding: 3px 9px; font: inherit; border: 1px solid var(--line); border-radius: 6px; background: transparent; color: var(--text); cursor: pointer; }
+.rd-retry:disabled { opacity: .5; cursor: default; }
 
 .rd-scroll { flex: 1 1 auto; overflow-y: auto; padding: 4px 16px 16px; min-height: 0; }
 

package/apps/agent-terminal/right-workspace-dock.js

@@ -123,6 +123,8 @@
     let listState = { loading: false, error: null, code: null, resync: false };
     let persistTimer = null;
     const taskIndex = new Map();
+    const taskLiveVersions = new Map();
+    let taskLiveRevision = 0, taskListRevision = 0;
     const delegationIndex = new Map();
     const delegationTitles = new Map();
     let delegationState = { loading: false, error: null, code: null };
@@ -282,6 +284,7 @@
       for (const [oldKey, old] of taskIndex) if (!old.taskRef && old.taskId === ref.taskId) taskIndex.delete(oldKey);
       const entry = taskIndex.get(key) || { key, taskRef: ref, sdkSessionId: null, taskId: null, taskKind: null, taskType: null, typeConflict: false, status: null, statusSource: null, association: null, rowCount: null };
       taskIndex.set(key, { ...entry, ...patch });
+      taskLiveVersions.set(key, ++taskLiveRevision);
     }
 
     function upsertFromStateEvent(ref, event) {
@@ -317,6 +320,7 @@
     }
 
     async function validateScopeTasks() {
+      const revision = ++taskListRevision;
       if (!scope || !scope.storeScope) {
         listState = { loading: false, error: '服务端任务身份不可用，无法读取原生任务列表。', code: 'TASK_IDENTITY_UNAVAILABLE', resync: false };
         for (const tab of tabs) if (tab.kind !== 'delegated' && (!tab.panel || !tab.panel.loaded)) tab.invalid = { code: 'TASK_IDENTITY_UNAVAILABLE', message: '服务端任务身份不可用；本切片不会伪造任务，也不会重新派发。' };
@@ -324,20 +328,23 @@
         return;
       }
       const epoch = scopeEpoch;
+      const liveRevision = taskLiveRevision;
       listState = { loading: true, error: null, code: null, resync: false };
       render();
       let page = null, error = null;
       try { page = await client.listNativeTasks(scope.parentSessionId, { storeScope: scope.storeScope, contextId: scope.contextId }); }
       catch (err) { error = err; }
-      if (epoch !== scopeEpoch) return;
+      if (epoch !== scopeEpoch || revision !== taskListRevision) return;
       if (error) {
         const code = (error && error.code) || String((error && error.status) || '');
         listState = { loading: false, error: `任务列表读取失败：${error.message || '未知错误'}`, code, resync: error.resync === true };
-        for (const tab of tabs) if (tab.kind !== 'delegated' && (!tab.panel || !tab.panel.loaded)) tab.invalid = { code, message: listState.error, resync: listState.resync };
+        for (const tab of tabs) if (!tab.kind && !taskIndex.has(taskRefKey(tab.taskRef)) && (!tab.panel || !tab.panel.loaded)) tab.invalid = { code, message: listState.error, resync: listState.resync };
         render();
         return;
       }
+      const newer = [...taskIndex.entries()].filter(([key]) => (taskLiveVersions.get(key) || 0) > liveRevision);
       rebuildIndex(page && Array.isArray(page.tasks) ? page.tasks : []);
+      for (const [key, entry] of newer) taskIndex.set(key, { ...taskIndex.get(key), ...entry });
       const incomplete = page && Array.isArray(page.incomplete) && page.incomplete.length > 0;
       listState = { loading: false, error: null, code: null, resync: incomplete ? 'incomplete' : false };
       // A rebuilt native index changes backgroundActivity (running counts);
@@ -383,6 +390,7 @@
         return;
       }
       panel.events = page && Array.isArray(page.events) ? page.events : [];
+      tab.invalid = null;
       panel.nextCursor = page && page.nextCursor || null;
       panel.hasMore = page ? page.hasMore === true : false;
       panel.loaded = true;
@@ -972,16 +980,28 @@
     // dispatch state and diagnostics never enter customer DOM.
     function createConversation(scroll) {
       let turn = null;
+      let group = null;
+      let eventTurnId = null;
+      const pending = [];
       const tools = new Map();
+      function startGroup(turnId) { group = { turnId: turnId || null, before: null, turn: null }; pending.push(group); }
       function current() {
-        if (!turn) turn = { messages: [], changes: [], process: null, live: null, thinking: null };
+        if (!turn) {
+          if (!group || !pending.includes(group)) startGroup(eventTurnId);
+          turn = { messages: [], changes: [], process: null, live: null, thinking: null, group };
+          group.turn = turn;
+        }
         return turn;
       }
+      function append(node, owner) {
+        if (owner?.group?.before?.parentNode === scroll) scroll.insertBefore(node, owner.group.before);
+        else scroll.append(node);
+      }
       function mark(node, sequence) {
         if (Number.isFinite(Number(sequence))) node.dataset.seq = String(sequence);
         return node;
       }
-      function message(role, text, sequence) {
+      function message(role, text, sequence, owner) {
         const node = renderMessage ? renderMessage(role, text) : el('div', role === 'user' ? 'msg user' : 'msg ai');
         let body = node.querySelector && node.querySelector(role === 'user' ? '.bubble' : '.md-body');
         if (!body) {
@@ -991,7 +1011,7 @@
           node.append(body);
         }
         mark(node, sequence);
-        scroll.append(node);
+        append(node, owner);
         return { node, body, text };
       }
       function process(sequence) {
@@ -1017,20 +1037,24 @@
         return t.process;
       }
       function updateProcess(p) { p.meta.textContent = p.steps.children.length + ' 个步骤'; }
-      function finish(sequence) {
-        if (!turn) return;
-        if (renderChanges && turn.changes.length) {
-          const changes = renderChanges(turn.changes);
-          if (changes) scroll.append(mark(changes, sequence));
+      function finish(sequence, owner = turn) {
+        if (!owner) return;
+        if (renderChanges && owner.changes.length) {
+          const changes = renderChanges(owner.changes);
+          if (changes) append(mark(changes, sequence), owner);
+          owner.changes = [];
         }
-        turn = null;
+        if (turn === owner) turn = null;
       }
       function accept(event) {
         if (!event) return;
+        eventTurnId = event.turnId || null;
         const seq = event.sequence, type = event.type;
         if (type === 'claude/user-prompt') {
           finish(seq);
-          if (event.text) message('user', String(event.text), seq);
+          const user = event.text ? message('user', String(event.text), seq) : null;
+          if (user) for (const old of pending) if (!old.before) old.before = user.node;
+          startGroup(event.turnId);
           current();
         } else if (type === 'claude/text-start') {
           current().live = null;
@@ -1079,15 +1103,20 @@
           mark(p.node, seq);
           updateProcess(p);
         } else if (type === 'claude/result') {
-          const t = current();
-          if (event.isError) scroll.append(mark(el('div', 'turn-note', '回复失败，请稍后重试。'), seq));
-          else if (!t.messages.length && event.result) message('assistant', String(event.result), seq);
-          finish(seq);
+          const index = event.turnId ? pending.findIndex(group => group.turnId === event.turnId) : 0;
+          if (event.turnId && index < 0) return;
+          const t = pending.splice(index, 1)[0]?.turn || current();
+          if (event.isError) append(mark(el('div', 'turn-note', '回复失败，请稍后重试。'), seq), t);
+          else if (!t.messages.length && event.result) message('assistant', String(event.result), seq, t);
+          finish(seq, t);
+        } else if (type === 'claude/turn-end') {
+          if (event.boundary !== 'result' && (!event.turnId || !group?.turnId || event.turnId === group.turnId)) finish(seq);
         } else if (type === 'conversation/unavailable') {
           scroll.append(mark(el('div', 'turn-note', '任务记录暂不可用，请刷新重试。'), seq));
         } else if (type === 'claude/aborted' || type === 'claude/task-interrupted' || type === 'claude/error') {
           scroll.append(mark(el('div', 'turn-note', type === 'claude/error' ? '回复失败，请稍后重试。' : '回复已中断'), seq));
           finish(seq);
+          pending.length = 0; group = null;
         }
       }
       return { accept, finish };
@@ -1161,7 +1190,8 @@
       pane.title.textContent = delegationTitle(tab.delegationId);
       pane.status.textContent = delegationStatus(view).label;
       pane.errorBox.hidden = !tab.invalid && !panel.error;
-      if (tab.invalid || panel.error) pane.errorBox.textContent = '暂时无法查看此任务，请刷新后重试。';
+      if (tab.invalid || panel.error) pane.errorText.textContent = '暂时无法查看此任务。';
+      pane.retry.disabled = panel.loading === true;
       pane.banner.hidden = true;
       if (tab.invalid) {
         pane.scroll.textContent = '';
@@ -1169,7 +1199,7 @@
         return;
       }
       if (!panel.rendered) renderDelegationTimeline(tab);
-      if (tab.error || tab.connectionError) { pane.errorBox.hidden = false; pane.errorBox.textContent = tab.error || tab.connectionError; }
+      if (tab.error || tab.connectionError) { pane.errorBox.hidden = false; pane.errorText.textContent = tab.error || tab.connectionError; }
       if (pane.composer) { pane.composer.setBusy(childBusy(tab)); pane.composer.send.disabled = Boolean(tab.invalid || tab.sending || !view || !view.child.present); }
       if (pane.composer && view) pane.composer.setLabel?.((view.child.model || '子代理') + ' · 默认防护');
       renderPermissions(tab);
@@ -1267,6 +1297,7 @@
       const previousScope = scope;
       flushPersist();
       scopeEpoch += 1;
+      taskLiveVersions.clear();
       scope = sanitizeScope(input);
       restoreFor(scope, previousScope);
       pickerOpen = false;
@@ -1711,6 +1742,10 @@
       banner.append(bannerText, resyncBtn);
       const errorBox = el('div', 'rd-error');
       errorBox.hidden = true;
+      const errorText = el('span');
+      const retry = el('button', 'rd-retry', '重试');
+      retry.addEventListener('click', () => { void (tab.kind === 'delegated' ? loadDelegationFirstPage(tab) : loadPanelFirstPage(tab)); });
+      errorBox.append(errorText, retry);
       const scroll = el('div', 'rd-scroll');
       scroll.addEventListener('scroll', () => {
         const pane = tab.pane;
@@ -1737,7 +1772,7 @@
         });
         node.append(continuation);
       }
-      tab.pane = { node, head, title, status, banner, bannerText, resyncBtn, errorBox, scroll, more,
+      tab.pane = { node, head, title, status, banner, bannerText, resyncBtn, errorBox, errorText, retry, scroll, more,
         follow: true, anchorSeq: null, anchorNote: null, pendingNew: false };
     }
 
@@ -1867,7 +1902,8 @@
       pane.title.textContent = taskTitle(entry);
       pane.status.textContent = entry && !entry.typeConflict ? (STATUS_LABELS[entry.status] || '状态待确认') : '状态待确认';
       pane.errorBox.hidden = !tab.invalid && !panel.error;
-      if (tab.invalid || panel.error) pane.errorBox.textContent = '暂时无法查看此任务，请刷新后重试。';
+      if (tab.invalid || panel.error) pane.errorText.textContent = '暂时无法查看此任务。';
+      pane.retry.disabled = panel.loading === true;
       pane.banner.hidden = !panel.resync;
       if (panel.resync) pane.bannerText.textContent = '记录已更新，请刷新查看。';
       if (tab.invalid) {

package/docs/sdk/SESSION_EVENTS.md

@@ -10,6 +10,8 @@ Session summaries include `tasks` and `backgroundTaskCount`. Task records use ac
 
 `claude/turn-end` closes the foreground reply. For Claude SDK streaming input this may occur at `end_turn` before its aggregate `result`, which can wait for background tasks. The input queue and event reader remain alive while tasks run. When foreground and tasks are both idle, the query is collected after 30 seconds; the next input resumes the same native session. Changing provider/model while a task runs is rejected.
 
+Claude SDK inputs now carry an optional opaque `turnId` on `claude/user-prompt` and the normalized response events. Match a delayed `claude/result` to that input, even when a newer prompt is already visible; a result for an input outside a loaded history page must not become the current reply. `claude/turn-end` with `boundary: "result"` is the boundary for the result already processed, rather than another active reply. Older journals without `turnId` retain their original ordered input/result pairing.
+
 Bound native agent tasks also persist evidence rows in the same journal: `claude/native-trace` (sanitized in-process hook facts), `claude/native-task-state` (ownership/status projections) and `claude/native-task-transcript` (a snapshot of a bound agent's transcript read through the SDK's public `getSubagentMessages` at a real terminal signal, or at the bounded turn-end sweep). Transcript rows carry `source: "sdk-public-read"`, fixed content-free `read` reason codes when a read cannot happen honestly, byte-bounded `chunk` markers, and normalized redacted entries/tool steps/usage - a snapshot read, never a claim of per-token streaming. These rows are part of the single-session stream's named event vocabulary: the standalone client subscribes to `claude/native-trace`, `claude/native-task-state`, `claude/native-task-transcript` and `claude/task-interrupted` like every other chat event, so SDK consumers receive the native facts in real time. They are additionally read back through the two read-only native-task history APIs (`GET /sessions/:id/native-tasks`, `POST /sessions/:id/native-tasks/history`), which page them without dispatching input.
 
 Set `inputOrigin: "agent-delegation"` explicitly when creating a Leader-dispatched session and on its input options. A delegated session cannot reclassify itself as human. Browser composers identify human input; unmarked legacy/API records remain unknown. This provenance follows the durable capture event key through the event bridge. No task is inferred from prose claiming that an agent is running. Drivers advertise `capabilities.backgroundTasks`; unsupported drivers show the limitation explicitly.

package/docs/sdk/openapi.yaml

@@ -1,7 +1,7 @@
 openapi: 3.1.0
 info:
   title: Claude AI Workbench API
-  version: 0.13.5
+  version: 0.13.6
   description: Versioned local API for AI Profile, credential and Claude Code session management.
 servers:
   - url: http://127.0.0.1:5760/api/claude-workbench/v1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanqianx/claude-ai-workbench",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "description": "Shared Claude Code terminal and Anthropic-compatible AI profile modules for local developer tools.",
   "type": "commonjs",
   "main": "src/index.js",

package/packages/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-ai-workbench/client",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "type": "commonjs",
   "main": "index.js",
   "browser": "index.js",
@@ -20,7 +20,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@claude-ai-workbench/contracts": "0.13.5"
+    "@claude-ai-workbench/contracts": "0.13.6"
   },
   "engines": {
     "node": ">=18"

package/packages/contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-ai-workbench/contracts",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "type": "commonjs",
   "main": "index.js",
   "types": "index.d.ts",

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-ai-workbench/core",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "type": "commonjs",
   "main": "index.js",
   "browser": "index.js",
@@ -20,7 +20,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@claude-ai-workbench/contracts": "0.13.5"
+    "@claude-ai-workbench/contracts": "0.13.6"
   },
   "engines": {
     "node": ">=18"

package/packages/server/lib/session-history.js

@@ -20,7 +20,8 @@ function parseLine(text) {
 
 function compactInto(events, event) {
   const previous = events[events.length - 1];
-  if (previous && DELTAS.has(event.type) && previous.type === event.type && previous.id === event.id) {
+  if (previous && DELTAS.has(event.type) && previous.type === event.type && previous.id === event.id
+    && previous.parentToolUseId === event.parentToolUseId && previous.sdkSessionId === event.sdkSessionId && previous.turnId === event.turnId) {
     previous.text = String(previous.text || '') + String(event.text || '');
     // Provenance for later recovery: a merged row spans from its first
     // fragment's sequence, so a stale partial buffer can be told to replace

package/packages/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-ai-workbench/server",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "type": "commonjs",
   "main": "index.js",
   "types": "index.d.ts",
@@ -25,7 +25,7 @@
   ],
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.141",
-    "@claude-ai-workbench/contracts": "0.13.5"
+    "@claude-ai-workbench/contracts": "0.13.6"
   },
   "engines": {
     "node": ">=18"

package/packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-ai-workbench/ui",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "type": "commonjs",
   "main": "ai-profile-settings.js",
   "browser": "ai-profile-settings.js",
@@ -33,7 +33,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@claude-ai-workbench/core": "0.13.5"
+    "@claude-ai-workbench/core": "0.13.6"
   },
   "engines": {
     "node": ">=18"

package/src/backend/lib/claude-cli-runner.js

@@ -874,6 +874,10 @@ function cutSdkExecutionForNativeHistory(session, phase) {
 }
 
 function emit(session, event) {
+  if (event.type === 'claude/user-prompt') {
+    event.turnId ||= crypto.randomUUID();
+    session.inputTurnId = event.turnId;
+  } else if (session.sdkEventTurnId && !event.turnId) event.turnId = session.sdkEventTurnId;
   if (session.sdkEventParentToolUseId && !event.parentToolUseId) event.parentToolUseId = session.sdkEventParentToolUseId;
   // Only the SDK message currently being processed may lend its session id,
   // and only to events that state no fact of their own: an explicit
@@ -1462,6 +1466,7 @@ async function sendInput(sessionId, text, aiProfile = null, opts = {}) {
   }
   const isFresh = !session.claudeSessionId;
   emit(session, { type: 'claude/user-prompt', text, inputOrigin: opts.inputOrigin || 'unknown', attachments: Array.isArray(opts.displayAttachments) ? opts.displayAttachments : [], isFollowUp: !isFresh, isFresh });
+  const inputTurnId = session.inputTurnId;
   const sdkOverrides = buildSdkOverridesFromProfile(aiProfile);
   session.permissionMode = normalizePermissionMode(opts.permissionMode || session.permissionMode || 'default');
   const envModel = session.claudeEnv && session.claudeEnv.ANTHROPIC_MODEL
@@ -1484,7 +1489,7 @@ async function sendInput(sessionId, text, aiProfile = null, opts = {}) {
     try {
       if (resident.query?.setPermissionMode) await resident.query.setPermissionMode(turnOpts.permissionMode);
       if (turnOpts.effort && resident.query?.setMaxThinkingTokens) await resident.query.setMaxThinkingTokens(EFFORT_THINKING_BUDGETS[normalizeEffortLevel(turnOpts.effort)]);
-      for await (const message of createSdkPrompt(turnOpts.userPrompt, turnOpts.attachments)) resident.send(message);
+      for await (const message of createSdkPrompt(turnOpts.userPrompt, turnOpts.attachments)) resident.send(message, inputTurnId);
       session.turns++;
       setState(session, 'running', { turn: session.turns, runner: 'sdk' });
     } catch (error) { resident.close('input-failed'); throw error; }
@@ -1920,7 +1925,7 @@ async function runSdkTurn(session, opts, isResume, generation) {
       const attemptToolInputBuffers = attempt === 0 ? toolInputBuffers : new Map();
       try {
         const { SdkSessionStream, mainReplyEnded } = require('./sdk-session-stream');
-        const transport = new SdkSessionStream({ onMessage: message => {
+        const transport = new SdkSessionStream({ onMessage: (message, ownership) => {
           if (!isCurrent()) return;
           if (!message.parent_tool_use_id && message.session_id) session.claudeSessionId = message.session_id;
           session.sdkEventParentToolUseId = message.parent_tool_use_id || null;
@@ -1930,9 +1935,10 @@ async function runSdkTurn(session, opts, isResume, generation) {
           // SDK envelope, and the stored claudeSessionId is never used to
           // backfill identity.
           session.sdkEventSessionId = typeof message.session_id === 'string' && message.session_id !== '' ? message.session_id : null;
+          session.sdkEventTurnId = ownership.turnId;
           let event;
           try { event = handleNdjsonLine(session, JSON.stringify(message), attemptToolInputBuffers); }
-          finally { session.sdkEventParentToolUseId = null; session.sdkEventSessionId = null; }
+          finally { session.sdkEventParentToolUseId = null; session.sdkEventSessionId = null; session.sdkEventTurnId = null; }
           // Existing normalized events were emitted above; the registry feed
           // comes strictly afterwards, and background subagent messages keep
           // arriving here after the main reply's end_turn.
@@ -1942,21 +1948,21 @@ async function runSdkTurn(session, opts, isResume, generation) {
           if (session.nativeTranscriptCollector) {
             try { session.nativeTranscriptCollector.notifySdkMessage(message); } catch { /* transcript reads must never break the stream */ }
           }
-          if (!message.parent_tool_use_id && event?.type === 'claude/result') {
+          if (!message.parent_tool_use_id && event?.type === 'claude/result' && ownership.isCurrentTurn) {
             if (event.isError) {
               session.error = event.result || 'Claude Code returned an error result';
               setState(session, 'failed', { error: session.error });
             } else setState(session, 'idle', { exitCode: 0, message: 'turn complete, awaiting input' });
-            emit(session, { type: 'claude/turn-end', exitCode: event.isError ? 1 : 0 });
+            emit(session, { type: 'claude/turn-end', exitCode: event.isError ? 1 : 0, boundary: 'result', turnId: ownership.turnId });
             // The query is ending: one bounded sweep reads every bound agent
             // already in a terminal state, so a completed background task is
             // never truncated by the main reply's end.
             if (session.nativeTranscriptCollector) {
               try { session.nativeTranscriptCollector.sweep('turn-end'); } catch { /* a sweep must never break the stream */ }
             }
-          } else if (mainReplyEnded(message) && session.state !== 'idle') {
+          } else if (mainReplyEnded(message) && ownership.isCurrentTurn && session.state !== 'idle') {
             setState(session, 'idle', { message: 'main reply complete; background notifications remain subscribed' });
-            emit(session, { type: 'claude/turn-end', exitCode: 0, boundary: 'end_turn' });
+            emit(session, { type: 'claude/turn-end', exitCode: 0, boundary: 'end_turn', turnId: ownership.turnId });
             if (session.nativeTranscriptCollector) {
               try { session.nativeTranscriptCollector.sweep('end-turn-boundary'); } catch { /* a sweep must never break the stream */ }
             }
@@ -1965,7 +1971,7 @@ async function runSdkTurn(session, opts, isResume, generation) {
           }
         } });
         session.sdkTransport = transport;
-        for await (const message of createSdkPrompt(opts.userPrompt, opts.attachments)) transport.send(message);
+        for await (const message of createSdkPrompt(opts.userPrompt, opts.attachments)) transport.send(message, opts.turnId);
         queryInstance = query({
           prompt: transport.input,
           options: sdkOptions,
@@ -2042,6 +2048,7 @@ async function runSdkTurn(session, opts, isResume, generation) {
 }
 
 function startSdkTurn(session, opts, isResume) {
+  opts.turnId ||= session.inputTurnId;
   const generation = (session.sdkTurnGeneration || 0) + 1;
   session.sdkTurnGeneration = generation;
   session.pendingPermission = null;

package/src/backend/lib/sdk-session-stream.js

@@ -10,6 +10,12 @@ class SdkSessionStream {
     this.clearTimer = clearTimer;
     this.foregroundRunning = false;
     this.completedTurns = 0;
+    // A reply can end before its input's result arrives. Keep each input
+    // pending until that ordered result, even after accepting another input.
+    this.pendingTurns = [];
+    this.messageTurns = new Map();
+    this.currentTurn = null;
+    this.responseTurn = null;
     this.tasks = new Map();
     this.queue = [];
     this.waiter = null;
@@ -31,11 +37,13 @@ class SdkSessionStream {
   // unrecognized literal: still active, never a claimed terminal state.
   get activeTaskCount() { return [...this.tasks.values()].filter(status => status === 'running' || status === 'pending' || status === UNKNOWN_TASK_STATUS).length; }
 
-  send(message) {
+  send(message, turnId = message.uuid || null) {
     if (this.closed) throw Object.assign(new Error('session transport is closed'), { code: 'SESSION_CLOSED' });
     if (this.foregroundRunning) throw Object.assign(new Error('session already has an active turn'), { code: 'TURN_BUSY', status: 409 });
     this.cancelIdle();
     this.foregroundRunning = true;
+    this.currentTurn = { ended: false, turnId };
+    this.pendingTurns.push(this.currentTurn);
     if (this.waiter) { const resolve = this.waiter; this.waiter = null; resolve({ value: message, done: false }); }
     else this.queue.push(message);
   }
@@ -55,14 +63,32 @@ class SdkSessionStream {
 
   observe(message) {
     const nested = Boolean(message.parent_tool_use_id);
+    let owner = this.responseTurn || this.currentTurn;
+    if (!nested && message.type === 'stream_event' && message.event?.type === 'message_start') {
+      if (!this.pendingTurns.length) {
+        this.currentTurn = { ended: false, turnId: this.currentTurn?.turnId || null };
+        this.pendingTurns.push(this.currentTurn);
+      }
+      owner = this.pendingTurns.find(turn => !turn.ended) || this.currentTurn;
+      this.responseTurn = owner;
+      if (message.event.message?.id && owner) this.messageTurns.set(message.event.message.id, owner);
+    } else if (!nested && message.type === 'assistant' && message.message?.id) {
+      // The completed assistant envelope can trail its streamed end_turn.
+      owner = this.messageTurns.get(message.message.id) || owner;
+    } else if (!nested && message.type === 'result') {
+      owner = this.pendingTurns.shift() || owner;
+    }
+    const isCurrentTurn = !owner || owner === this.currentTurn;
     if (message.type === 'system' && message.task_id) this._observeTask(message);
     if (!nested && (message.type === 'result' || mainReplyEnded(message))) {
-      this.foregroundRunning = false;
+      if (owner) owner.ended = true;
+      if (isCurrentTurn) this.foregroundRunning = false;
       if (message.type === 'result') this.completedTurns++;
     } else if (!nested && message.type === 'stream_event' && message.event?.type === 'message_start') {
-      this.foregroundRunning = true;
+      if (owner) owner.ended = false;
+      if (isCurrentTurn) this.foregroundRunning = true;
     }
-    this.onMessage(message);
+    this.onMessage(message, { isCurrentTurn, turnId: owner?.turnId || null });
     this.cancelIdle();
     if (!this.foregroundRunning && !this.activeTaskCount) {
       this.idleTimer = this.setTimer(() => this.close('idle'), this.idleMs);