= 2
+ for idx in inactive_returns[:2]:
+ branch = wire_fn[idx:wire_fn.find("}", idx) + 1]
+ assert "recordActivityBoundary();" in branch
+ assert "_resetAssistantSegment();" in branch
+
+
+def test_tool_event_flushes_pending_text_before_inserting_activity():
+ """A tool card must not appear before the text segment it is anchored to.
+
+ Token rendering is throttled through rAF. On mobile/slow clients a `tool`
+ event can arrive while the current assistantRow exists but its pending text
+ has not been written into `.msg-body` yet. If appendLiveToolCard() runs
+ first, the Activity group appears, then the delayed flush fills the empty
+ segment above it a frame later, which looks like process text was inserted
+ before an already-visible Activity row.
+ """
+ tool_handler = MESSAGES_JS.split("source.addEventListener('tool',e=>{", 1)[1].split("source.addEventListener('tool_complete'", 1)[0]
+ flush_pos = tool_handler.find("_flushPendingSegmentRender({force:true});")
+ append_pos = tool_handler.find("appendLiveToolCard(tc")
+ assert flush_pos != -1 and append_pos != -1
+ assert flush_pos < append_pos
+
+
+def test_pending_text_flush_syncs_existing_worklog_reason():
+ """If Activity was created before text was flushed, the next text render must
+ move that text into the existing Worklog instead of leaving it as a separate
+ assistant segment above the tool rows.
+ """
+ assert "function _syncLiveWorklogReasonsForAnchor(anchor, displayTextOverride)" in UI_JS
+ flush_fn = MESSAGES_JS.split("function _flushPendingSegmentRender(options={})", 1)[1].split("function _resetAssistantSegment", 1)[0]
+ assert "_syncLiveWorklogReasonsForAnchor(assistantRow, displayText)" in flush_fn
+ render_fn = MESSAGES_JS.split("const _doRender=()=>{", 1)[1].split("scrollIfPinned();", 1)[0]
+ assert "_syncLiveWorklogReasonsForAnchor(assistantRow, displayText)" in render_fn
+
+
+def test_pending_text_flush_passes_display_text_to_worklog_reason_sync():
+ """Forced flush owns the authoritative displayText for this frame.
+
+ Do not make Worklog reason synchronization depend only on reading the
+ already-rendered DOM: streaming-markdown can lag a frame behind the known
+ displayText during bursty token/tool boundaries.
+ """
+ sync_fn = _function_source(UI_JS, "_syncLiveWorklogReasonsForAnchor")
+ assert "displayTextOverride" in sync_fn
+ assert "_syncWorklogReasonFromAnchor(group, anchor, displayTextOverride)" in sync_fn
+ flush_fn = MESSAGES_JS.split("function _flushPendingSegmentRender(options={})", 1)[1].split("function _resetAssistantSegment", 1)[0]
+ assert "_syncLiveWorklogReasonsForAnchor(assistantRow, displayText)" in flush_fn
+ render_fn = MESSAGES_JS.split("const _doRender=()=>{", 1)[1].split("scrollIfPinned();", 1)[0]
+ assert "_syncLiveWorklogReasonsForAnchor(assistantRow, displayText)" in render_fn
+
+
+def test_tool_event_does_not_create_blank_text_segment_without_pending_text():
+ """Tool-only bursts should not create empty assistant text segments.
+
+ A tool event can arrive before any visible answer text exists. Forcing
+ ensureAssistantRow(true) in that path creates a blank `.assistant-segment`
+ above every Activity group, making Live Stream look unstable during long
+ polling turns.
+ """
+ tool_handler = MESSAGES_JS.split("source.addEventListener('tool',e=>{", 1)[1].split("source.addEventListener('tool_complete'", 1)[0]
+ upsert_pos = tool_handler.find("const tc=upsertLiveToolCall(d,'start');")
+ guard_pos = tool_handler.find("String(pendingDisplayText||'').trim()")
+ force_pos = tool_handler.find("ensureAssistantRow(true);")
+ append_pos = tool_handler.find("appendLiveToolCard(tc")
+ assert upsert_pos != -1 and guard_pos != -1 and force_pos != -1 and append_pos != -1
+ assert upsert_pos < guard_pos < force_pos < append_pos
+ assert "if(!assistantRow||!assistantBody) ensureAssistantRow(true);" not in tool_handler
+
+
+def test_orphan_tool_complete_does_not_create_blank_text_segment_without_pending_text():
+ """An orphan tool_complete should not manufacture an empty assistant segment."""
+ complete_handler = MESSAGES_JS.split("source.addEventListener('tool_complete',e=>{", 1)[1].split("source.addEventListener('approval'", 1)[0]
+ orphan_branch = complete_handler.split("if(tc._createdByComplete){", 1)[1].split("} else {", 1)[0]
+ guard_pos = orphan_branch.find("String(pendingDisplayText||'').trim()")
+ force_pos = orphan_branch.find("ensureAssistantRow(true);")
+ flush_pos = orphan_branch.find("_flushPendingSegmentRender({force:true});")
+ append_pos = orphan_branch.find("appendLiveToolCard(tc")
+ assert guard_pos != -1 and force_pos != -1 and flush_pos != -1 and append_pos != -1
+ assert guard_pos < force_pos < flush_pos < append_pos
+ assert "if(!assistantRow||!assistantBody) ensureAssistantRow(true);" not in orphan_branch
+
+
+def test_reattach_segment_start_aligns_with_last_burst_anchor():
+ """Simulate the reattach segmentStart initializer with multiple anchors.
+
+ The initializer must clamp to the actual assistantText length and ignore
+ stale anchors past the end of the text, otherwise displayText slicing in
+ _doRender would produce empty output for the tail segment.
+ """
+ assert NODE, "node not on PATH"
+ body = MESSAGES_JS.split("function attachLiveStream(", 1)[1]
+ seg_block_start = body.find("let segmentStart=(()=>{")
+ assert seg_block_start != -1, "expected reconnect-aware segmentStart IIFE"
+ seg_block_end = body.find("})();", seg_block_start) + len("})();")
+ initializer = body[seg_block_start:seg_block_end] + ";"
+ # Wrap as a callable with explicit reconnecting + INFLIGHT/activeSid stand-ins.
+ script = f"""
+const assert = require('assert');
+function computeStart(reconnecting, inflight, assistantText) {{
+ const INFLIGHT = {{ 'sid': inflight }};
+ const activeSid = 'sid';
+ {initializer}
+ return segmentStart;
+}}
+// No anchors -> 0
+assert.strictEqual(computeStart(true, {{activityBurstAnchors:[]}}, 'hello world'), 0);
+// Single anchor inside text length -> anchor textEnd
+assert.strictEqual(computeStart(true, {{activityBurstAnchors:[{{id:1,textEnd:5}}]}}, 'hello world'), 5);
+// Multiple anchors -> picks max textEnd within text length
+assert.strictEqual(computeStart(true, {{activityBurstAnchors:[
+ {{id:1,textEnd:5}}, {{id:2,textEnd:11}}, {{id:3,textEnd:7}}
+]}}, 'hello world'), 11);
+// Anchor textEnd past assistantText length -> ignored
+assert.strictEqual(computeStart(true, {{activityBurstAnchors:[
+ {{id:1,textEnd:5}}, {{id:2,textEnd:99}}
+]}}, 'hello world'), 5);
+// Not reconnecting -> always 0
+assert.strictEqual(computeStart(false, {{activityBurstAnchors:[
+ {{id:1,textEnd:5}}, {{id:2,textEnd:11}}
+]}}, 'hello world'), 0);
+// Missing inflight entry -> 0
+assert.strictEqual(computeStart(true, undefined, 'hello'), 0);
+"""
+ result = subprocess.run([NODE, "-e", script], capture_output=True, text=True, check=False)
+ assert result.returncode == 0, result.stderr
def test_activity_status_rows_have_quiet_metadata_styling():
diff --git a/tests/test_live_stream_ux.py b/tests/test_live_stream_ux.py
index cc7ca0140d..2f03f34bf8 100644
--- a/tests/test_live_stream_ux.py
+++ b/tests/test_live_stream_ux.py
@@ -36,8 +36,6 @@ def test_recovery_control_detection_is_not_broad_phrase_matching():
assert "|| /continue exactly where you left off/i.test(normalized)" not in MESSAGES_JS
assert "const systemRecovery=/^\\[System:/i.test(normalized)" in UI_JS
assert "const backendRecovery=/^the live worker stopped before this run finished\\.?$/i.test(normalized)" in UI_JS
-
-
def test_recovery_control_does_not_filter_genuine_interruption_card():
"""A real 'Response interrupted' card carries provider_details_label
'Interruption details' but is NOT a recovery-control row — it must stay
diff --git a/tests/test_live_tool_callback_events.py b/tests/test_live_tool_callback_events.py
index 74c8b3430f..2997b45413 100644
--- a/tests/test_live_tool_callback_events.py
+++ b/tests/test_live_tool_callback_events.py
@@ -68,6 +68,10 @@ def test_tool_callback_events_keep_existing_frontend_event_contract():
assert "source.addEventListener('tool',e=>{" in messages
assert "source.addEventListener('tool_complete',e=>{" in messages
- assert "tid:d.tid" in messages
+ assert "String(d&&d.tid" in messages or "explicitTid=String(d&&d.tid" in messages, (
+ "frontend tool handlers must still consume explicit server tid when present"
+ )
+ assert "upsertLiveToolCall(d,'start')" in messages
+ assert "upsertLiveToolCall(d,'complete')" in messages
assert "data-live-tid" in ui
assert "existing.replaceWith(replacement)" in ui
diff --git a/tests/test_regressions.py b/tests/test_regressions.py
index a887e8f76d..890413ba5f 100644
--- a/tests/test_regressions.py
+++ b/tests/test_regressions.py
@@ -428,7 +428,7 @@ def test_loadSession_inflight_restores_live_tool_cards(cleanup_test_sessions):
# INFLIGHT branch must call appendLiveToolCard
inflight_idx = src.find("if(INFLIGHT[sid]){")
assert inflight_idx >= 0, "INFLIGHT branch not found in loadSession"
- inflight_block = src[inflight_idx:inflight_idx+1600]
+ inflight_block = src[inflight_idx:inflight_idx+4200]
assert "appendLiveToolCard" in inflight_block, "loadSession INFLIGHT branch must restore live tool cards via appendLiveToolCard"
assert "clearLiveToolCards" in inflight_block, "loadSession INFLIGHT branch must clear old live cards before restoring"
@@ -543,6 +543,18 @@ def test_chat_start_persists_pending_turn_metadata_for_reload_recovery(cleanup_t
assert '"pending_user_message": getattr(s, "pending_user_message", None)' in routes_src
+def test_session_detail_uses_runtime_streaming_state(cleanup_test_sessions):
+ """GET /api/session must agree with /api/sessions on live stream ownership."""
+ routes_src = (REPO_ROOT / "api/routes.py").read_text()
+ session_route = routes_src.split('if parsed.path == "/api/session":', 1)[1].split(
+ 'if parsed.path == "/api/session/lineage/report":', 1
+ )[0]
+ assert "active_stream_ids = _active_stream_ids()" in session_route
+ assert "s.compact(" in session_route
+ assert "include_runtime=True" in session_route
+ assert "active_stream_ids=active_stream_ids" in session_route
+
+
def test_reload_path_restores_pending_message_and_reattaches_live_stream(cleanup_test_sessions):
"""R15d: the frontend reload path must show the pending user turn and
reattach to the live SSE stream after loadSession().
@@ -558,6 +570,19 @@ def test_reload_path_restores_pending_message_and_reattaches_live_stream(cleanup
'const activeStreamId=S.session.active_stream_id||null;' in sessions_src)
assert 'attachLiveStream(sid, activeStreamId' in sessions_src
assert 'if (S.activeStreamId && S.activeStreamId === streamId) return;' in ui_src
+ active_branch_start = sessions_src.index("if(activeStreamId){\n S.busy=true;")
+ active_branch_end = sessions_src.index("}else{\n S.busy=false;", active_branch_start)
+ active_branch = sessions_src[active_branch_start:active_branch_end]
+ render_pos = active_branch.index("renderMessages(")
+ shell_pos = active_branch.index("ensureLiveWorklogShell")
+ assert render_pos < shell_pos, (
+ "Reloading an active stream must recreate the live worklog shell after "
+ "renderMessages() rebuilds msgInner; otherwise the stream stays invisible "
+ "until a session switch triggers another restore path."
+ )
+ assert "else appendThinking();" in active_branch, (
+ "Non-simplified tool-calling must keep the legacy fallback."
+ )
# ── R16: Switching away/back must preserve live partial assistant output ─────
@@ -609,7 +634,7 @@ def test_inflight_session_state_tracks_live_tool_cards_per_session(cleanup_test_
messages_src = (REPO_ROOT / "static/messages.js").read_text()
sessions_src = (REPO_ROOT / "static/sessions.js").read_text()
- assert "INFLIGHT[activeSid].toolCalls.push(tc);" in messages_src, \
+ assert "inflight.toolCalls.push(tc)" in messages_src, \
"tool SSE handler must persist live tool calls onto the in-flight session"
assert "S.toolCalls=(INFLIGHT[sid].toolCalls||[]);" in sessions_src, \
"loadSession() must restore live tool calls from the in-flight session state"
@@ -624,7 +649,7 @@ def test_loadSession_inflight_sets_busy_before_renderMessages(cleanup_test_sessi
src = (REPO_ROOT / "static/sessions.js").read_text()
inflight_idx = src.find("if(INFLIGHT[sid]){")
assert inflight_idx >= 0, "INFLIGHT branch not found in loadSession"
- inflight_block = src[inflight_idx:inflight_idx+1600]
+ inflight_block = src[inflight_idx:inflight_idx+4200]
busy_pos = inflight_block.find("S.busy=true;")
# #3326 added an optional {preserveScroll} arg to the INFLIGHT-branch render
# call, so match the call form rather than the bare `renderMessages();`.
@@ -652,6 +677,34 @@ def test_loadSession_inflight_merges_tail_with_persisted_transcript(cleanup_test
)
+def test_renderMessages_preserves_loading_placeholder_for_session_switch(cleanup_test_sessions):
+ """R16d: renderMessages should not repaint transcript during session-load window.
+
+ During loadSession(sid) after the loading metadata call, S.messages is
+ intentionally empty until _ensureMessagesLoaded(sid) settles. A concurrent
+ renderMessages() must keep the existing 'Loading conversation...' placeholder
+ instead of clearing #msgInner to an empty transcript.
+ """
+ ui_src = (REPO_ROOT / "static/ui.js").read_text()
+ fn_start = ui_src.find("function renderMessages")
+ assert fn_start >= 0, "renderMessages() not found in ui.js"
+ fn_body = ui_src[fn_start:fn_start + 1400]
+
+ compact = re.sub(r"\s+", "", fn_body)
+ assert (
+ "if(_loadingSessionId===sid&&msgCount===0&&inner)return;" in compact
+ ), (
+ "renderMessages() must return early when loadSession is active for"
+ " the current sid and S.messages is still empty."
+ )
+
+ # Guard must live before render-window reset and message-filter pass.
+ reset_pos = compact.find("if(sid!==_messageRenderWindowSid)_resetMessageRenderWindow(sid);")
+ guard_pos = compact.find("if(_loadingSessionId===sid&&msgCount===0&&inner)return;")
+ assert (
+ 0 <= guard_pos < reset_pos
+ ), "Session-load empty-state guard must run before render-window/state resets."
+
def test_browser_session_url_accepts_api_session_id_param(cleanup_test_sessions):
"""External links using ?session_id=... should open that session in the browser.
@@ -705,7 +758,7 @@ def test_loadSession_inflight_sets_active_stream_before_replaying_live_tool_card
src = (REPO_ROOT / "static/sessions.js").read_text()
inflight_idx = src.find("if(INFLIGHT[sid]){")
assert inflight_idx >= 0, "INFLIGHT branch not found in loadSession"
- inflight_block = src[inflight_idx:inflight_idx+1600]
+ inflight_block = src[inflight_idx:inflight_idx+4200]
active_pos = inflight_block.find("S.activeStreamId=activeStreamId;")
replay_pos = inflight_block.find("appendLiveToolCard(tc);")
attach_pos = inflight_block.find("attachLiveStream(sid, activeStreamId")
@@ -773,12 +826,19 @@ def test_messages_js_supports_live_reasoning_and_tool_completion(cleanup_test_se
# On initial connect it defaults to ''; on reconnect it restores from
# INFLIGHT so the already-rendered content survives the session switch.
assert ("let reasoningText=''" in src
- or "let reasoningText = _lastLiveAssistant" in src), \
+ or "let reasoningText = _lastLiveAssistant" in src
+ or "let reasoningText=_lastLiveReasoning" in src), \
"messages.js must track streamed reasoning text separately from assistant text"
- assert ("let liveReasoningText=''" in src or "let liveReasoningText = reasoningText" in src), \
+ assert ("let liveReasoningText=''" in src
+ or "let liveReasoningText = reasoningText" in src
+ or "let liveReasoningText=_lastLiveReasoning" in src), \
"messages.js must track the currently active reasoning segment separately from cumulative reasoning"
assert "source.addEventListener('reasoning'" in src or 'source.addEventListener("reasoning"' in src, \
"messages.js must listen for live reasoning SSE events"
+ assert "liveReasoningText += text" in src, \
+ "live reasoning SSE events must update the active Worklog Thinking Card text"
+ assert "_updateLiveThinkingCard(_liveThinkingText())" in src, \
+ "live reasoning SSE events must refresh the current segment's Worklog Thinking Card"
assert "source.addEventListener('tool_complete'" in src or 'source.addEventListener("tool_complete"' in src, \
"messages.js must listen for live tool completion SSE events"
assert "function _parseStreamState()" in src, \
@@ -803,14 +863,15 @@ def test_messages_js_supports_interim_assistant_events(cleanup_test_sessions):
def test_ui_js_can_upgrade_thinking_spinner_into_live_reasoning_card(cleanup_test_sessions):
- """R19: ui.js must be able to replace the placeholder thinking spinner with
- streamed reasoning text while a turn is in progress.
+ """R19: ui.js keeps the thinking helpers available while simplified mode
+ renders provider reasoning as a Worklog Thinking Card.
"""
src = (REPO_ROOT / "static/ui.js").read_text()
assert "function _thinkingMarkup(text='')" in src or 'function _thinkingMarkup(text="")' in src, \
"ui.js must centralize thinking row markup so it can switch between spinner and live text"
- assert "function updateThinking(text=''){appendThinking(text);}" in src or 'function updateThinking(text=""){appendThinking(text);}' in src, \
- "ui.js must expose an updateThinking helper for live reasoning rendering"
+ assert ("function updateThinking(text='', options){appendThinking(text, options);}" in src
+ or 'function updateThinking(text="", options){appendThinking(text, options);}' in src), \
+ "ui.js must expose an updateThinking helper that preserves live Thinking placement metadata"
assert "function finalizeThinkingCard()" in src, \
"ui.js must expose a helper to finalize one live thinking card before starting another"
@@ -841,15 +902,23 @@ def test_ui_js_keeps_reasoning_only_assistant_messages_visible(cleanup_test_sess
def test_ui_js_does_not_hide_anchor_segments_that_contain_thinking(cleanup_test_sessions):
- """R19c2/R19c3: reasoning-only messages must remain visible through the
- shared compact timeline activity UI, even when the anchor segment has no prose.
+ """R19c2/R19c3: reasoning-only metadata must remain preserved as a
+ collapsed Worklog Thinking Card.
"""
src = (REPO_ROOT / "static" / "ui.js").read_text()
compact = src.replace(' ', '').replace('\n', '')
assert "assistantThinking.set(rawIdx,thinkingText)" in compact, \
"renderMessages must preserve reasoning text before hiding empty anchor segments"
+ helper_start = src.find("function _worklogReasoningTextFromMessage")
+ helper_end = src.find("function _thinkingCardHtml", helper_start)
+ assert helper_start != -1 and helper_end != -1
+ helper = src[helper_start:helper_end]
+ assert "_assistantReasoningPayloadText(m)" in helper and "_stripVisibleAssistantEchoFromThinking" in helper, \
+ "provider reasoning metadata should feed the Worklog Thinking Card after exact duplicate suppression"
+ assert "data-worklog-thinking-card" in src, \
+ "Thinking Cards should be explicit Worklog items, not tool cards"
assert "_thinkingActivityNode(thinkingText, false)" in src, \
- "thinking-only assistant content should render as a collapsed timeline Thinking card"
+ "settled reasoning should render as a collapsed Worklog Thinking Card"
def test_messages_js_live_assistant_segment_reuses_live_turn_wrapper(cleanup_test_sessions):
@@ -872,12 +941,20 @@ def test_messages_js_live_assistant_segment_reuses_live_turn_wrapper(cleanup_tes
def test_messages_js_finalizes_thinking_card_before_tool_card(cleanup_test_sessions):
- """R19e: later reasoning after a tool call must render in a fresh card."""
+ """R19e: later reasoning after a tool call must render in a fresh Worklog
+ Thinking Card without discarding durable reasoning.
+ """
src = (REPO_ROOT / "static/messages.js").read_text()
- assert "finalizeThinkingCard" in src, \
+ tool_start = src.find("source.addEventListener('tool'")
+ tool_complete_start = src.find("source.addEventListener('tool_complete'", tool_start + 1)
+ assert tool_start >= 0 and tool_complete_start > tool_start
+ body = src[tool_start:tool_complete_start]
+ assert "finalizeThinkingCard()" in body, \
"tool handler must finalize the current live thinking card before appending a tool card"
- assert "liveReasoningText='';" in src or 'liveReasoningText = "";' in src, \
+ assert "liveReasoningText='';" in body or 'liveReasoningText = "";' in body, \
"tool handler must reset the active reasoning segment before post-tool reasoning arrives"
+ assert "reasoningText=''" not in body and 'reasoningText = ""' not in body, \
+ "tool handler must not discard durable reasoning already assigned to the Worklog"
# ── R17: Stack traces must not leak to clients in 500 responses ────────────
diff --git a/tests/test_run_journal.py b/tests/test_run_journal.py
index 22a7b24eb4..84f30e0924 100644
--- a/tests/test_run_journal.py
+++ b/tests/test_run_journal.py
@@ -27,6 +27,26 @@ def test_run_journal_appends_monotonic_seq_and_reads_after_cursor(tmp_path):
assert [event["event"] for event in journal["events"]] == ["done"]
+def test_run_journal_reads_bounded_replay_window(tmp_path):
+ writer = RunJournalWriter("session_1", "run_1", session_dir=tmp_path)
+
+ writer.append_sse_event("token", {"text": "one"})
+ writer.append_sse_event("token", {"text": "two"})
+ writer.append_sse_event("token", {"text": "three"})
+ writer.append_sse_event("token", {"text": "four"})
+
+ journal = read_run_events(
+ "session_1",
+ "run_1",
+ after_seq=1,
+ max_seq=3,
+ session_dir=tmp_path,
+ )
+
+ assert [event["seq"] for event in journal["events"]] == [2, 3]
+ assert [event["payload"]["text"] for event in journal["events"]] == ["two", "three"]
+
+
def test_run_journal_default_fsyncs_terminal_events_only(tmp_path, monkeypatch):
path = tmp_path / "_run_journal" / "session_1" / "run_1.jsonl"
path.parent.mkdir(parents=True)
diff --git a/tests/test_run_journal_frontend_static.py b/tests/test_run_journal_frontend_static.py
index 5b8ea81a1b..9a10058442 100644
--- a/tests/test_run_journal_frontend_static.py
+++ b/tests/test_run_journal_frontend_static.py
@@ -11,7 +11,7 @@ def test_reattach_path_uses_replay_when_status_reports_journal():
assert "st.replay_available" in block
assert "replayOnly=true" in block
- assert "replayOnly?_runJournalReplayParams():''" in block
+ assert "(reconnecting||replayOnly)?_runJournalReplayParams():''" in block
assert "_clearOwnerInflightState()" in block
@@ -64,8 +64,15 @@ def test_replayed_long_task_events_enter_the_same_live_timeline_handlers():
f"{event_name} must be handled by the shared live/replay SSE pipeline"
)
- assert "updateThinking(" in wire_block, "reasoning replay should use the live Thinking card path"
- assert "appendLiveToolCard(tc)" in wire_block, "tool replay should use live tool-card rendering"
+ thinking_helper = MESSAGES_SRC[
+ MESSAGES_SRC.index("function _updateLiveThinkingCard") :
+ MESSAGES_SRC.index("// Split a content string", MESSAGES_SRC.index("function _updateLiveThinkingCard"))
+ ]
+ assert "_updateLiveThinkingCard(" in wire_block, "reasoning replay should use the live Thinking card path"
+ assert "updateThinking(text, opts)" in thinking_helper and "appendThinking(text, opts)" in thinking_helper, (
+ "the shared Thinking helper should still route replay/live reasoning into the Worklog Thinking card path"
+ )
+ assert "appendLiveToolCard(tc" in wire_block, "tool replay should use live tool-card rendering"
# Compression replay must dispatch through setCompressionUi(...). The handler
# body may build the state object inline (`setCompressionUi({...})`) or hoist
# it into a `state` variable first (`setCompressionUi(state)`) — both forms
diff --git a/tests/test_run_journal_routes.py b/tests/test_run_journal_routes.py
index 862a18a391..bae7aacdc1 100644
--- a/tests/test_run_journal_routes.py
+++ b/tests/test_run_journal_routes.py
@@ -1,6 +1,8 @@
from pathlib import Path
from types import SimpleNamespace
+from urllib.parse import urlparse
import io
+import queue
ROOT = Path(__file__).resolve().parents[1]
@@ -24,10 +26,232 @@ def test_dead_stream_sse_replays_journal_before_404_fallback():
assert "find_run_summary(stream_id)" in block
assert "stream not found" in block
assert "_replay_run_journal" in block
- assert "_parse_run_journal_after_seq(qs, stream_id)" in block
+ assert "_parse_run_journal_after_seq" in block
assert 'Content-Type", "text/event-stream; charset=utf-8"' in block
+def test_active_stream_replay_uses_snapshot_cutoff_and_skips_duplicate_queue_items(monkeypatch):
+ import api.routes as routes
+
+ class FakeStream:
+ def __init__(self):
+ self.q = queue.Queue()
+ self.q.put_nowait(("token", {"text": "replayed"}, "run_1:1"))
+ self.q.put_nowait(("stream_end", {}, "run_1:2"))
+ self.unsubscribed = False
+
+ def subscribe_with_snapshot(self):
+ return self.q, {"last_event_id": "run_1:1", "offline_buffered_events": 1}
+
+ def unsubscribe(self, q):
+ self.unsubscribed = q is self.q
+
+ class Handler:
+ def __init__(self):
+ self.wfile = io.BytesIO()
+
+ def send_response(self, _code):
+ pass
+
+ def send_header(self, _name, _value):
+ pass
+
+ def end_headers(self):
+ pass
+
+ handler = Handler()
+ stream = FakeStream()
+ monkeypatch.setattr(
+ routes,
+ "find_run_summary",
+ lambda stream_id: {
+ "session_id": "session_1",
+ "run_id": stream_id,
+ "terminal": False,
+ },
+ )
+ monkeypatch.setattr(
+ routes,
+ "read_run_events",
+ lambda session_id, run_id, after_seq=None, max_seq=None: {
+ "events": [
+ {
+ "event": "token",
+ "payload": {"text": "replayed"},
+ "event_id": f"{run_id}:1",
+ }
+ ]
+ },
+ )
+ monkeypatch.setattr(routes, "stale_interrupted_event", lambda *_args, **_kwargs: None)
+ previous_streams = dict(routes.STREAMS)
+ routes.STREAMS.clear()
+ routes.STREAMS["run_1"] = stream
+ try:
+ routes._handle_sse_stream(handler, urlparse("/api/chat/stream?stream_id=run_1&replay=1&after_seq=0"))
+ finally:
+ routes.STREAMS.clear()
+ routes.STREAMS.update(previous_streams)
+
+ body = handler.wfile.getvalue().decode("utf-8")
+ assert body.count("event: token\n") == 1
+ assert "id: run_1:1\n" in body
+ assert "id: run_1:2\n" in body
+ assert stream.unsubscribed is True
+
+
+def test_active_stream_snapshot_keeps_items_for_new_run_with_same_seq_range(monkeypatch):
+ import api.routes as routes
+
+ class FakeStream:
+ def __init__(self):
+ self.q = queue.Queue()
+ self.q.put_nowait(("token", {"text": "fresh"}, "run_new:1"))
+ self.q.put_nowait(("stream_end", {}, "run_new:2"))
+ self.unsubscribed = False
+
+ def subscribe_with_snapshot(self):
+ return self.q, {
+ "last_event_id": "run_old:3",
+ "offline_buffered_events": 2,
+ }
+
+ def unsubscribe(self, q):
+ self.unsubscribed = q is self.q
+
+ class Handler:
+ def __init__(self):
+ self.wfile = io.BytesIO()
+
+ def send_response(self, _code):
+ pass
+
+ def send_header(self, _name, _value):
+ pass
+
+ def end_headers(self):
+ pass
+
+ handler = Handler()
+ stream = FakeStream()
+ monkeypatch.setattr(
+ routes,
+ "find_run_summary",
+ lambda stream_id: {
+ "session_id": "session_2",
+ "run_id": stream_id,
+ "terminal": False,
+ },
+ )
+ monkeypatch.setattr(
+ routes,
+ "read_run_events",
+ lambda session_id, run_id, after_seq=None, max_seq=None: {"events": []},
+ )
+ monkeypatch.setattr(routes, "stale_interrupted_event", lambda *_args, **_kwargs: None)
+ previous_streams = dict(routes.STREAMS)
+ routes.STREAMS.clear()
+ routes.STREAMS["run_new"] = stream
+ try:
+ routes._handle_sse_stream(
+ handler,
+ urlparse("/api/chat/stream?stream_id=run_new&replay=1&after_seq=0"),
+ )
+ finally:
+ routes.STREAMS.clear()
+ routes.STREAMS.update(previous_streams)
+
+ body = handler.wfile.getvalue().decode("utf-8")
+ assert "id: run_new:1\n" in body
+ assert "id: run_new:2\n" in body
+ assert body.count("id: run_new:1\n") == 1
+ assert stream.unsubscribed is True
+
+
+def test_active_stream_replay_without_journal_keeps_buffered_queue_items(monkeypatch):
+ import api.routes as routes
+
+ class FakeStream:
+ def __init__(self):
+ self.q = queue.Queue()
+ self.q.put_nowait(("token", {"text": "buffered"}, "missing_journal_run:1"))
+ self.q.put_nowait(("stream_end", {}, "missing_journal_run:2"))
+
+ def subscribe_with_snapshot(self):
+ return self.q, {"last_event_id": "missing_journal_run:1", "offline_buffered_events": 1}
+
+ def unsubscribe(self, _q):
+ pass
+
+ class Handler:
+ def __init__(self):
+ self.wfile = io.BytesIO()
+
+ def send_response(self, _code):
+ pass
+
+ def send_header(self, _name, _value):
+ pass
+
+ def end_headers(self):
+ pass
+
+ monkeypatch.setattr(routes, "find_run_summary", lambda _stream_id: None)
+ handler = Handler()
+ previous_streams = dict(routes.STREAMS)
+ routes.STREAMS.clear()
+ routes.STREAMS["missing_journal_run"] = FakeStream()
+ try:
+ routes._handle_sse_stream(
+ handler,
+ urlparse("/api/chat/stream?stream_id=missing_journal_run&replay=1&after_seq=0"),
+ )
+ finally:
+ routes.STREAMS.clear()
+ routes.STREAMS.update(previous_streams)
+
+ body = handler.wfile.getvalue().decode("utf-8")
+ assert "id: missing_journal_run:1\n" in body
+ assert "event: token\n" in body
+ assert "buffered" in body
+
+
+def test_live_sse_uses_each_queue_items_own_event_id():
+ import api.routes as routes
+ from api.config import create_stream_channel
+
+ class Handler:
+ def __init__(self):
+ self.wfile = io.BytesIO()
+
+ def send_response(self, _code):
+ pass
+
+ def send_header(self, _name, _value):
+ pass
+
+ def end_headers(self):
+ pass
+
+ stream = create_stream_channel()
+ stream.put_nowait(("token", {"text": "A"}, "run_own_id:1"))
+ stream.put_nowait(("stream_end", {"ok": True}, "run_own_id:2"))
+ handler = Handler()
+ previous_streams = dict(routes.STREAMS)
+ routes.STREAMS.clear()
+ routes.STREAMS["run_own_id"] = stream
+ try:
+ routes._handle_sse_stream(handler, urlparse("/api/chat/stream?stream_id=run_own_id"))
+ finally:
+ routes.STREAMS.clear()
+ routes.STREAMS.update(previous_streams)
+
+ body = handler.wfile.getvalue().decode("utf-8")
+ assert "id: run_own_id:1\nevent: token\n" in body
+ assert "id: run_own_id:2\nevent: stream_end\n" in body
+ assert body.count("id: run_own_id:2\n") == 1
+
+
def test_replay_emits_event_ids_and_stale_restart_diagnostic():
replay_pos = ROUTES_SRC.index("def _replay_run_journal")
block = ROUTES_SRC[replay_pos : replay_pos + 1200]
@@ -100,7 +324,7 @@ def test_replay_run_journal_writes_replayed_events_and_synthetic_terminal(monkey
monkeypatch.setattr(
routes,
"read_run_events",
- lambda session_id, run_id, after_seq=None: {
+ lambda session_id, run_id, after_seq=None, max_seq=None: {
"events": [
{
"event": "token",
@@ -113,7 +337,7 @@ def test_replay_run_journal_writes_replayed_events_and_synthetic_terminal(monkey
monkeypatch.setattr(
routes,
"stale_interrupted_event",
- lambda session_id, run_id, after_seq=None: {
+ lambda session_id, run_id, after_seq=None, max_seq=None: {
"event": "apperror",
"payload": {"type": "interrupted"},
"event_id": f"{run_id}:2",
@@ -143,8 +367,9 @@ def test_replay_run_journal_honors_after_seq_cursor(monkeypatch):
},
)
- def fake_read_run_events(session_id, run_id, after_seq=None):
+ def fake_read_run_events(session_id, run_id, after_seq=None, max_seq=None):
captured["after_seq"] = after_seq
+ captured["max_seq"] = max_seq
return {
"events": [
{
@@ -159,27 +384,75 @@ def fake_read_run_events(session_id, run_id, after_seq=None):
assert routes._replay_run_journal(handler, "run_1", 3) is True
assert captured["after_seq"] == 3
+ assert captured["max_seq"] is None
body = handler.wfile.getvalue().decode("utf-8")
assert "id: run_1:4\n" in body
assert "event: done\n" in body
-def test_parse_run_journal_after_seq_is_run_aware():
+def test_active_stream_replay_keeps_items_for_new_run_with_same_seq_range(monkeypatch):
import api.routes as routes
- assert routes._parse_run_journal_after_seq(
- {"after_event_id": ["new-run:7"], "after_seq": ["7"]},
- "new-run",
- ) == 7
- assert routes._parse_run_journal_after_seq(
- {"after_event_id": ["old-run:7"], "after_seq": ["7"]},
- "new-run",
- ) is None
- assert routes._parse_run_journal_after_seq({"after_seq": ["3"]}, "new-run") == 3
-
-
-def test_frontend_sends_run_aware_replay_cursor():
- messages_src = (ROOT / "static" / "messages.js").read_text(encoding="utf-8")
- assert "let _lastRunJournalEventId=''" in messages_src
- assert "_lastRunJournalEventId=raw" in messages_src
- assert "after_event_id=${encodeURIComponent(_lastRunJournalEventId||'')}" in messages_src
+ class FakeStream:
+ def __init__(self):
+ self.q = queue.Queue()
+ self.q.put_nowait(("token", {"text": "fresh"}, "run_new:1"))
+ self.q.put_nowait(("stream_end", {}, "run_new:2"))
+ self.unsubscribed = False
+
+ def subscribe_with_snapshot(self):
+ return self.q, {
+ "last_event_id": "run_old:3",
+ "offline_buffered_events": 2,
+ }
+
+ def unsubscribe(self, q):
+ self.unsubscribed = q is self.q
+
+ class Handler:
+ def __init__(self):
+ self.wfile = io.BytesIO()
+
+ def send_response(self, _code):
+ pass
+
+ def send_header(self, _name, _value):
+ pass
+
+ def end_headers(self):
+ pass
+
+ handler = Handler()
+ stream = FakeStream()
+ monkeypatch.setattr(
+ routes,
+ "find_run_summary",
+ lambda stream_id: {
+ "session_id": "session_2",
+ "run_id": stream_id,
+ "terminal": False,
+ },
+ )
+ monkeypatch.setattr(
+ routes,
+ "read_run_events",
+ lambda session_id, run_id, after_seq=None, max_seq=None: {"events": []},
+ )
+ monkeypatch.setattr(routes, "stale_interrupted_event", lambda *_args, **_kwargs: None)
+ previous_streams = dict(routes.STREAMS)
+ routes.STREAMS.clear()
+ routes.STREAMS["run_new"] = stream
+ try:
+ routes._handle_sse_stream(
+ handler,
+ urlparse("/api/chat/stream?stream_id=run_new&replay=1&after_seq=0"),
+ )
+ finally:
+ routes.STREAMS.clear()
+ routes.STREAMS.update(previous_streams)
+
+ body = handler.wfile.getvalue().decode("utf-8")
+ assert "id: run_new:1\n" in body
+ assert "id: run_new:2\n" in body
+ assert body.count("id: run_new:1\n") == 1
+ assert stream.unsubscribed is True
diff --git a/tests/test_run_journal_streaming_static.py b/tests/test_run_journal_streaming_static.py
index 90b64cca0c..ea455a13c8 100644
--- a/tests/test_run_journal_streaming_static.py
+++ b/tests/test_run_journal_streaming_static.py
@@ -15,14 +15,9 @@ def test_streaming_journals_sse_events_before_queue_delivery():
src = Path("api/streaming.py").read_text(encoding="utf-8")
put_idx = src.index("def put(event, data):")
journal_idx = src.index("run_journal.append_sse_event(event, data)", put_idx)
- # Stage-364 maintainer fix: put() now pushes 3-tuples (event, data, event_id)
- # so the SSE consumer can emit `id:` on live frames. Accept either shape
- # so this test survives both the v0.51.71 in-flight fix and a future revert.
- try:
- queue_idx = src.index("q.put_nowait((event, data, event_id))", put_idx)
- except ValueError:
- queue_idx = src.index("q.put_nowait((event, data))", put_idx)
+ queue_idx = src.index("q.put_nowait(queue_item)", put_idx)
block = src[put_idx:queue_idx]
assert put_idx < journal_idx < queue_idx
assert "Failed to append run journal event" in block
+ assert "queue_item = (event, data, event_id) if event_id and hasattr(q, \"subscribe_with_snapshot\") else (event, data)" in block
diff --git a/tests/test_session_attention_badges.py b/tests/test_session_attention_badges.py
index a2c75272cc..3772de013d 100644
--- a/tests/test_session_attention_badges.py
+++ b/tests/test_session_attention_badges.py
@@ -148,6 +148,13 @@ def test_session_sidebar_renders_attention_badge_and_semantic_classes():
assert ".session-item.attention-clarify" in style_css
# The text-badge styles were removed; the dot now carries the color.
assert ".session-attention-badge" not in style_css
+ assert "is-attention-clarify" in sessions_js, (
+ "renderSessionList must tag the state indicator with is-attention-clarify."
+ )
assert ".session-state-indicator.is-attention-approval" in style_css
assert ".session-state-indicator.is-attention-clarify" in style_css
+ assert ".session-state-indicator.is-attention-generic{visibility:visible;}" in style_css
+ assert ".session-state-indicator.is-attention-approval{color:var(--error);}" in style_css
+ assert ".session-state-indicator.is-attention-clarify{color:var(--warning);}" in style_css
+ assert ".session-state-indicator.is-attention-generic{color:var(--warning);}" in style_css
assert "prefers-reduced-motion" in style_css
diff --git a/tests/test_session_rotate_url_sync.py b/tests/test_session_rotate_url_sync.py
index a275f97814..9c0736ec0b 100644
--- a/tests/test_session_rotate_url_sync.py
+++ b/tests/test_session_rotate_url_sync.py
@@ -1,5 +1,6 @@
"""Regression tests for session id rotation URL sync."""
from pathlib import Path
+import re
REPO_ROOT = Path(__file__).parent.parent.resolve()
MESSAGES_JS = (REPO_ROOT / "static" / "messages.js").read_text(encoding="utf-8")
@@ -9,16 +10,20 @@ def test_stream_completion_syncs_rotated_session_id_to_tab_state():
"""When compact/restore returns a new session id, the tab anchor follows it."""
# #3018 inserted a carry-forward of ephemeral per-turn fields into both the
# completion (_finishDone) and settled-restore assignments; match the new shapes.
- completion_marker = "S.session=d.session;S.messages=_carryForwardEphemeralTurnFields(S.messages||[], d.session.messages||[]);"
+ completion_marker = re.compile(
+ r"S\.session=d\.session;\s*"
+ r"S\.messages=_carryForwardEphemeralTurnFields\(S\.messages\|\|\[\], d\.session\.messages\|\|\[\]\);"
+ )
settled_marker = "S.session=session;\n const _nextMsgs3018=(session.messages||[]).filter(m=>m&&m.role);"
- completion_pos = MESSAGES_JS.find(completion_marker)
+ completion_match = completion_marker.search(MESSAGES_JS)
+ completion_pos = completion_match.start() if completion_match else -1
settled_pos = MESSAGES_JS.find(settled_marker)
assert completion_pos != -1
assert settled_pos != -1
- completion_block = MESSAGES_JS[completion_pos : completion_pos + 900]
- settled_block = MESSAGES_JS[settled_pos : settled_pos + 900]
+ completion_block = MESSAGES_JS[completion_pos : completion_pos + 800]
+ settled_block = MESSAGES_JS[settled_pos : settled_pos + 800]
for block in (completion_block, settled_block):
assert "localStorage.setItem('hermes-webui-session',S.session.session_id);" in block
diff --git a/tests/test_sprint42.py b/tests/test_sprint42.py
index 8e37aded77..b2d6381e0d 100644
--- a/tests/test_sprint42.py
+++ b/tests/test_sprint42.py
@@ -403,12 +403,39 @@ def path(self):
self.assertTrue(callable(init_kwargs["interim_assistant_callback"]))
self.assertIn("WebUI progress guidance", captured["agent"].ephemeral_system_prompt)
self.assertIn("Match the normal Hermes messaging style", captured["agent"].ephemeral_system_prompt)
- self.assertIn("user-visible progress updates", captured["agent"].ephemeral_system_prompt)
+ self.assertIn(
+ "do not let long tool-running WebUI turns appear silent",
+ captured["agent"].ephemeral_system_prompt,
+ )
+ self.assertIn(
+ "emit brief user-visible progress updates as normal assistant content",
+ captured["agent"].ephemeral_system_prompt,
+ )
+ self.assertIn(
+ "Before the first tool batch in a long task",
+ captured["agent"].ephemeral_system_prompt,
+ )
+ self.assertIn(
+ "Do not run many independent tool batches back-to-back without visible assistant text between them",
+ captured["agent"].ephemeral_system_prompt,
+ )
+ self.assertIn(
+ "Do not keep progress only in reasoning, thinking, or tool-result channels",
+ captured["agent"].ephemeral_system_prompt,
+ )
+ self.assertNotIn(
+ "you may provide brief user-visible progress updates",
+ captured["agent"].ephemeral_system_prompt,
+ )
interim_events = []
while not fake_queue.empty():
try:
- interim_events.append(fake_queue.get_nowait())
+ item = fake_queue.get_nowait()
+ if isinstance(item, tuple) and len(item) >= 2:
+ interim_events.append((item[0], item[1]))
+ else:
+ interim_events.append(item)
except queue.Empty:
break
self.assertTrue(
@@ -724,11 +751,11 @@ def test_done_handler_patches_reasoning_field():
src = (REPO / 'static' / 'messages.js').read_text()
# The persistence comment must be present inside the done handler
- assert "Persist reasoning trace so thinking card survives page reload" in src, \
+ assert "Persist reasoning trace for Worklog Thinking Cards" in src, \
"Reasoning persistence comment not found in messages.js done handler"
# The guard and assignment must be present
- assert "if(reasoningText){" in src, \
+ assert "if(reasoningText&&lastAsst&&!lastAsst.reasoning)" in src, \
"reasoningText guard not found in messages.js"
assert "lastAsst.reasoning=reasoningText" in src, \
@@ -736,7 +763,7 @@ def test_done_handler_patches_reasoning_field():
# Verify the patch is inside the done handler (after 'source.addEventListener' for done)
done_handler_idx = src.index("source.addEventListener('done'")
- persist_idx = src.index("Persist reasoning trace so thinking card survives page reload")
+ persist_idx = src.index("Persist reasoning trace for Worklog Thinking Cards")
assert done_handler_idx < persist_idx, \
"Reasoning persistence patch must be inside the done SSE handler"
@@ -745,21 +772,21 @@ def test_done_handler_patches_reasoning_field():
"Guard '!lastAsst.reasoning' missing — would overwrite server-persisted reasoning"
-def test_rendermessages_reads_reasoning_from_messages():
- """ui.js renderMessages must read m.reasoning to display the thinking card."""
+def test_rendermessages_keeps_reasoning_metadata_out_of_worklog_display():
+ """ui.js renderMessages must not promote provider reasoning metadata into Worklog prose."""
src = (REPO / 'static' / 'ui.js').read_text()
- # m.reasoning must be read in the render path
- assert 'm.reasoning' in src, \
- "m.reasoning not referenced in ui.js — thinking card won't render on reload"
+ sig_fn = src.split("function _messageHasReasoningPayload(m)", 1)[1].split("function", 1)[0]
+ assert 'm.reasoning' in sig_fn, \
+ "m.reasoning should remain part of metadata/cache signature handling"
- # The thinking card rendering block must also be present
+ # Legacy thinking-card helpers may still exist for explicit debug surfaces.
assert 'thinking-card' in src, \
"thinking-card CSS class not found in ui.js"
- # Specifically, the fallback that reads from top-level m.reasoning field
- assert 'thinkingText=m.reasoning' in src.replace(' ', ''), \
- "thinkingText=m.reasoning assignment not found in ui.js renderMessages"
+ extraction = src.split("let thinkingText='';", 1)[1].split("const isUser=m.role==='user';", 1)[0]
+ assert 'm.reasoning' not in extraction
+ assert 'm.reasoning_content' not in extraction
def test_streaming_restores_prior_reasoning_metadata_after_followup():
diff --git a/tests/test_stage364_opus_live_sse_event_id.py b/tests/test_stage364_opus_live_sse_event_id.py
index 855212124d..eb36504c3e 100644
--- a/tests/test_stage364_opus_live_sse_event_id.py
+++ b/tests/test_stage364_opus_live_sse_event_id.py
@@ -1,4 +1,4 @@
-"""Regression test for stage-364 Opus-caught SHOULD-FIX (side-channel approach):
+"""Regression test for stage-364 Opus-caught SHOULD-FIX (per-frame cursor):
When the live SSE stream errors mid-stream and the frontend falls back to
journal replay, live frames must carry an `id:` field so the frontend's
@@ -7,19 +7,17 @@
seq 1, double-rendering tokens against the live-phase `assistantText`
accumulator.
-Implementation (stage-364 — side-channel approach to avoid breaking the
-queue tuple contract used by 4 existing tests):
+Implementation:
- api/config.py adds `STREAM_LAST_EVENT_ID: dict = {}` module-level dict.
- api/streaming.py `put()` captures `journaled["event_id"]` from
`RunJournalWriter.append_sse_event()` return and writes it to
`STREAM_LAST_EVENT_ID[stream_id]`.
- - api/routes.py `_handle_sse_stream` reads `STREAM_LAST_EVENT_ID[stream_id]`
- at SSE emit time and uses `_sse_with_id` when set.
+ - StreamChannel queue items carry `(event, data, event_id)` so active
+ subscribers emit each frame with its own id instead of the latest global id.
+ - Legacy plain queues keep `(event, data)` and use `STREAM_LAST_EVENT_ID` as a
+ compatibility fallback.
- api/streaming.py finally-block cleanup pops STREAM_LAST_EVENT_ID.
-
-The queue tuple shape is preserved as (event, data), so existing tests like
-test_cancel_puts_sentinel_in_queue still work.
"""
from pathlib import Path
@@ -28,6 +26,7 @@
STREAMING_PY = (REPO_ROOT / "api" / "streaming.py").read_text(encoding="utf-8")
ROUTES_PY = (REPO_ROOT / "api" / "routes.py").read_text(encoding="utf-8")
CONFIG_PY = (REPO_ROOT / "api" / "config.py").read_text(encoding="utf-8")
+GATEWAY_CHAT_PY = (REPO_ROOT / "api" / "gateway_chat.py").read_text(encoding="utf-8")
def test_stream_last_event_id_dict_exists_in_config():
@@ -54,16 +53,27 @@ def test_put_writes_event_id_to_side_channel_dict():
)
-def test_queue_tuple_shape_preserved_as_two_tuple():
- """The queue still uses 2-tuples (event, data) so existing consumers
- that unpack `event, data = q.get()` are not broken."""
+def test_stream_channel_queue_item_carries_per_event_id_with_legacy_fallback():
+ """StreamChannel queue items need per-frame ids; legacy queues stay 2-tuples."""
put_def_idx = STREAMING_PY.find("def put(event, data):")
put_body = STREAMING_PY[put_def_idx:put_def_idx + 2500]
- assert "q.put_nowait((event, data))" in put_body, (
- "Queue tuple shape must remain (event, data) — changing to 3-tuple "
- "breaks 4 existing tests in test_cancel_interrupt, test_sprint42, "
- "test_sprint51, test_issue1857_usage_overwrite"
+ assert 'queue_item = (event, data, event_id) if event_id and hasattr(q, "subscribe_with_snapshot") else (event, data)' in put_body, (
+ "StreamChannel events must carry their own event_id while legacy queue "
+ "consumers retain the 2-tuple shape"
+ )
+ assert "q.put_nowait(queue_item)" in put_body
+
+
+def test_gateway_queue_item_carries_per_event_id_with_legacy_fallback():
+ """Gateway-backed WebUI chat must preserve the same live cursor invariant."""
+ put_def_idx = GATEWAY_CHAT_PY.find("def put_gateway_event(event, data):")
+ assert put_def_idx != -1, "put_gateway_event(event, data) not found"
+ put_body = GATEWAY_CHAT_PY[put_def_idx:put_def_idx + 1800]
+ assert 'queue_item = (event, data, event_id) if event_id and hasattr(q, "subscribe_with_snapshot") else (event, data)' in put_body, (
+ "Gateway live events must carry their own event_id for StreamChannel "
+ "subscribers while preserving legacy queue compatibility"
)
+ assert "q.put_nowait(queue_item)" in put_body
def test_sse_handler_reads_event_id_from_side_channel():
diff --git a/tests/test_stale_stream_cleanup.py b/tests/test_stale_stream_cleanup.py
index c66098e72e..de0f37e404 100644
--- a/tests/test_stale_stream_cleanup.py
+++ b/tests/test_stale_stream_cleanup.py
@@ -81,6 +81,80 @@ def test_chat_start_clears_stale_pending_state_not_only_active_id():
assert stale_comment_pos < cleanup_pos < stream_id_pos
+def test_chat_start_rechecks_active_stream_under_session_lock(monkeypatch, tmp_path):
+ """A concurrent chat_start must not overwrite stream ownership.
+
+ The first request can pass the pre-lock active_stream_id check while another
+ request is waiting/running. Once this request enters the session lock, it
+ must re-read active_stream_id and reject instead of creating a ghost stream.
+ """
+ config.STREAMS.clear()
+ config.SESSION_AGENT_LOCKS.clear()
+ existing_stream_id = "already-running-stream"
+
+ class ChatStartSession:
+ session_id = "duplicate-start-session"
+
+ def __init__(self):
+ self.active_stream_id = None
+ self.pending_user_message = None
+ self.pending_attachments = []
+ self.pending_started_at = None
+ self.messages = []
+ self.title = "Untitled"
+ self.worktree_path = None
+ self.workspace = None
+ self.model = None
+ self.model_provider = None
+
+ def save(self, *args, **kwargs):
+ return None
+
+ session = ChatStartSession()
+
+ class MutatingSessionLock:
+ def __enter__(self):
+ session.active_stream_id = existing_stream_id
+ session.pending_user_message = "prompt already claimed by another start"
+ session.pending_started_at = 123.0
+ routes.STREAMS[existing_stream_id] = queue.Queue()
+ return self
+
+ def __exit__(self, exc_type, exc, tb):
+ return False
+
+ class NoopThread:
+ def __init__(self, *args, **kwargs):
+ self.args = args
+ self.kwargs = kwargs
+
+ def start(self):
+ return None
+
+ monkeypatch.setattr(routes, "_get_session_agent_lock", lambda sid: MutatingSessionLock())
+ monkeypatch.setattr(routes.uuid, "uuid4", lambda: type("FakeUuid", (), {"hex": "new-stream"})())
+ monkeypatch.setattr(routes, "set_last_workspace", lambda workspace: None)
+ monkeypatch.setattr(routes, "create_stream_channel", lambda: queue.Queue())
+ monkeypatch.setattr(routes.threading, "Thread", NoopThread)
+
+ try:
+ response = routes._start_chat_stream_for_session(
+ session,
+ msg="please start once",
+ attachments=[],
+ workspace=str(tmp_path),
+ model="test-model",
+ model_provider=None,
+ )
+
+ assert response["_status"] == 409
+ assert response["active_stream_id"] == existing_stream_id
+ assert session.active_stream_id == existing_stream_id
+ assert "new-stream" not in routes.STREAMS
+ finally:
+ routes.STREAMS.pop(existing_stream_id, None)
+
+
def test_stale_stream_cleanup_does_not_clobber_concurrent_chat_start(monkeypatch):
"""Regression for #1533: stale cleanup must not erase a new stream id.
diff --git a/tests/test_streaming_race_fix.py b/tests/test_streaming_race_fix.py
index 36aed1f807..cfaea91c26 100644
--- a/tests/test_streaming_race_fix.py
+++ b/tests/test_streaming_race_fix.py
@@ -51,7 +51,9 @@ def test_schedule_render_guards_on_stream_finalized(self):
def test_raf_handle_stored_in_schedule_render(self):
src = read('static/messages.js')
- assert '_pendingRafHandle=requestAnimationFrame' in src or \
+ assert '_pendingRafHandle=_pendingRafFrameHandle' in src or \
+ '_pendingRafHandle = _pendingRafFrameHandle' in src or \
+ '_pendingRafHandle=requestAnimationFrame' in src or \
'_pendingRafHandle = requestAnimationFrame' in src, (
"rAF handle must be stored in _pendingRafHandle for cancellation"
)
diff --git a/tests/test_tars_scroll_reset_regressions.py b/tests/test_tars_scroll_reset_regressions.py
index 9d5fa79592..ba4543b2c7 100644
--- a/tests/test_tars_scroll_reset_regressions.py
+++ b/tests/test_tars_scroll_reset_regressions.py
@@ -78,17 +78,21 @@ def test_message_scroll_listener_does_not_downgrade_explicit_bottom_pin_on_first
def test_user_scroll_cancels_delayed_bottom_settling():
listener_block = _scroll_listener_block()
record = _function_body(UI_JS, "function _recordNonMessageScrollIntent")
+ pinned = _function_body(UI_JS, "function scrollIfPinned")
assert "function _cancelBottomSettle" in UI_JS
assert "_cancelBottomSettle();" in listener_block
assert "e.deltaY<0" in record
assert "_cancelBottomSettle();" in record
assert "_scrollPinned=false" in record
+ assert "if(_messageUserUnpinned) return;" in pinned
+ assert "_recentMessageUpwardIntent()" not in pinned
def test_preserve_scroll_restores_unpinned_viewport_after_dom_rebuild():
render = _function_body(UI_JS, "function renderMessages")
after_render = _function_body(UI_JS, "function _scrollAfterMessageRender")
+ follow = _function_body(UI_JS, "function _followMessagesAfterDomReplace")
restore = _function_body(UI_JS, "function _restoreMessageScrollSnapshot")
snapshot_idx = render.index("const scrollSnapshot=preserveScroll?_captureMessageScrollSnapshot():null")
@@ -99,7 +103,9 @@ def test_preserve_scroll_restores_unpinned_viewport_after_dom_rebuild():
"renderMessages({preserveScroll:true}) must capture #messages.scrollTop before "
"replacing transcript DOM, then pass that snapshot to the post-render scroll helper"
)
- assert "if(_scrollPinned) scrollIfPinned()" in after_render
- assert "else _restoreMessageScrollSnapshot(scrollSnapshot)" in after_render
+ assert "if(_followMessagesAfterDomReplace()) return;" in after_render
+ assert "_restoreMessageScrollSnapshot(scrollSnapshot)" in after_render
+ assert "_shouldFollowMessagesOnDomReplace()" in follow
+ assert "scrollToBottom();" in follow
assert "el.scrollTop=Math.max(0,Math.min(Number(snapshot.top)||0,maxTop))" in restore
assert "_programmaticScroll=true" in restore
diff --git a/tests/test_turn_duration_display.py b/tests/test_turn_duration_display.py
index 2bd1aef528..ae1ea6c342 100644
--- a/tests/test_turn_duration_display.py
+++ b/tests/test_turn_duration_display.py
@@ -53,10 +53,14 @@ def test_ui_formats_and_renders_turn_duration_in_footer_and_activity_summary():
"Compact tool activity summary should have a dedicated duration span at the end of the line."
)
assert "data-turn-duration" in UI_JS, (
- "Activity groups need a stable data-turn-duration hook so settled duration can update the summary."
+ "The spec Activity summary needs a stable data-turn-duration hook so settled duration can update its summary."
)
- assert "compactActivityForMessage" in UI_JS, (
- "When compact activity is present, duration should live on the Activity row "
+ assert "turnDuration:includeTurnDuration?_turnDurationForAnchor(anchorRow):undefined" in UI_JS, (
+ "Settled compact activity should put turn duration on the first spec Activity row, "
+ "not resurrect the legacy top Run Activity."
+ )
+ assert "compactWorklogForMessage" in UI_JS, (
+ "When folded Worklog detail is present, duration should live on the Worklog row "
"instead of being duplicated in the assistant footer."
)
assert ".msg-duration-inline" in CSS and ".tool-call-group-duration" in CSS, (
@@ -73,6 +77,11 @@ def test_active_compact_activity_elapsed_timer_uses_persisted_start_time():
"send() should copy chat-start pending_started_at into S.session before "
"attaching the live stream."
)
+ assert "showLiveRunStatus(activeSid,{startedAt:_startedAt});" in MESSAGES_JS, (
+ "The first chat-start path should show the bottom live footer timer as soon "
+ "as stream_id and pending_started_at are known; reconnect should not be the "
+ "only path that restores it."
+ )
assert "function _formatActiveElapsedTimer" in UI_JS and "padStart(2,'0')" in UI_JS, (
"ui.js should format the running timer in MM:SS form."
)
@@ -88,3 +97,18 @@ def test_active_compact_activity_elapsed_timer_uses_persisted_start_time():
"The active elapsed label should tick while running and clear its interval "
"on terminal/error/session-switch cleanup paths."
)
+
+
+def test_live_footer_timer_is_re_synced_after_message_rerender():
+ assert "function _syncLiveRunStatusAfterRender()" in UI_JS, (
+ "renderMessages() needs a dedicated helper so the live footer timer "
+ "can be restored after DOM rebuilds."
+ )
+ assert "_syncLiveRunStatusAfterRender();" in UI_JS, (
+ "renderMessages() should call the live-status sync helper after it "
+ "rebuilds msgInner."
+ )
+ assert "showLiveRunStatus(sid,{startedAt,tokens:_liveRunStatusTokens});" in UI_JS, (
+ "If the timer node was torn down during a rerender, the helper should "
+ "recreate it for the active session."
+ )
diff --git a/tests/test_ui_card_animation.py b/tests/test_ui_card_animation.py
index 3a84f4aca0..1cbbd9e77b 100644
--- a/tests/test_ui_card_animation.py
+++ b/tests/test_ui_card_animation.py
@@ -8,20 +8,20 @@
def test_tool_card_toggle_uses_transformable_layout_and_transition():
- assert ".tool-card-toggle{" in COMPACT_CSS
+ assert ".tool-card-toggle,.tl-caret{" in COMPACT_CSS
assert "display:inline-flex" in COMPACT_CSS
assert "transition:transform.18sease" in COMPACT_CSS
def test_tool_card_detail_uses_transitionable_collapsed_state():
- assert ".tool-card-detail{display:block;max-height:0;opacity:0;overflow:hidden;" in COMPACT_CSS
+ assert ".tool-card-detail,.tl-detail{display:block;max-height:0;opacity:0;overflow:hidden;" in COMPACT_CSS
assert re.search(
- r"\.tool-card\.open\s+\.tool-card-detail\s*\{[^}]*max-height:\s*600px;[^}]*opacity:\s*1;",
+ r"\.tool-card\.open\s+\.tool-card-detail,\s*\.tl\.open\s+\.tl-detail\s*\{[^}]*max-height:\s*320px;[^}]*opacity:\s*1;",
STYLE_CSS,
)
# Open state must set overflow to auto so the inner scroll is not clipped (#1170).
assert re.search(
- r"\.tool-card\.open\s+\.tool-card-detail\s*\{[^}]*overflow:\s*auto;",
+ r"\.tool-card\.open\s+\.tool-card-detail,\s*\.tl\.open\s+\.tl-detail\s*\{[^}]*overflow:\s*auto;",
STYLE_CSS,
)
diff --git a/tests/test_ui_tool_call_cleanup.py b/tests/test_ui_tool_call_cleanup.py
index 4d6c8d7364..20806879e6 100644
--- a/tests/test_ui_tool_call_cleanup.py
+++ b/tests/test_ui_tool_call_cleanup.py
@@ -4,8 +4,10 @@
source files, isolate the relevant function/rule, and assert implementation
invariants before changing the UI.
"""
+import json
import pathlib
import re
+import subprocess
REPO = pathlib.Path(__file__).parent.parent
UI_JS = (REPO / "static" / "ui.js").read_text(encoding="utf-8")
@@ -70,6 +72,86 @@ def _function_body(src: str, name: str) -> str:
return src[brace + 1:i - 1]
+def _function_src(src: str, name: str) -> str:
+ match = re.search(rf"function\s+{re.escape(name)}\s*\(", src)
+ assert match, f"{name}() not found"
+ brace = src.find("{", match.end())
+ assert brace != -1, f"{name}() has no body"
+ depth = 1
+ i = brace + 1
+ in_string = None
+ escaped = False
+ in_line_comment = False
+ in_block_comment = False
+ while i < len(src) and depth:
+ ch = src[i]
+ nxt = src[i + 1] if i + 1 < len(src) else ""
+ if in_line_comment:
+ if ch == "\n":
+ in_line_comment = False
+ i += 1
+ continue
+ if in_block_comment:
+ if ch == "*" and nxt == "/":
+ in_block_comment = False
+ i += 2
+ continue
+ i += 1
+ continue
+ if in_string:
+ if escaped:
+ escaped = False
+ elif ch == "\\":
+ escaped = True
+ elif ch == in_string:
+ in_string = None
+ i += 1
+ continue
+ if ch == "/" and nxt == "/":
+ in_line_comment = True
+ i += 2
+ continue
+ if ch == "/" and nxt == "*":
+ in_block_comment = True
+ i += 2
+ continue
+ if ch in "'\"`":
+ in_string = ch
+ i += 1
+ continue
+ if ch == "{":
+ depth += 1
+ elif ch == "}":
+ depth -= 1
+ i += 1
+ assert depth == 0, f"{name}() body did not close"
+ return src[match.start():i]
+
+
+def _run_thinking_echo_helper(*args: str) -> str:
+ helpers = "\n".join(
+ _function_src(UI_JS, name)
+ for name in (
+ "_stripXmlToolCallsDisplay",
+ "_sanitizeThinkingDisplayText",
+ "_normalizeThinkingEchoCompare",
+ "_stripVisibleAssistantEchoFromThinking",
+ )
+ )
+ script = (
+ helpers
+ + "\nconst args=JSON.parse(process.argv[1]);"
+ + "\nprocess.stdout.write(JSON.stringify(_stripVisibleAssistantEchoFromThinking(...args)));"
+ )
+ out = subprocess.run(
+ ["node", "-e", script, json.dumps(list(args))],
+ check=True,
+ capture_output=True,
+ text=True,
+ ).stdout
+ return json.loads(out)
+
+
class TestToolCallGroupingStatic:
def test_simplified_tool_calling_setting_is_wired_through_frontend(self):
assert "settingsSimplifiedToolCalling" in (REPO / "static" / "index.html").read_text(encoding="utf-8"), (
@@ -99,11 +181,14 @@ def test_simplified_tool_calling_autosave_hot_applies_renderer_mode(self):
def test_render_messages_gates_settled_activity_grouping(self):
fn = _function_body(UI_JS, "renderMessages")
helper = _function_body(UI_JS, "ensureActivityGroup")
- assert "isSimplifiedToolCalling()" in fn, (
- "Settled compact inline activity rendering should be gated by the Compact tool activity toggle."
+ assert "byActivity = new Map()" in fn, (
+ "Settled tool rendering should bucket by worklog segments/bursts."
+ )
+ assert "_toolWorklogListEl(group)" in fn, (
+ "Settled tools should render through the worklog list container."
)
- assert "tool-cards-toggle" in fn, (
- "The non-simplified path should preserve the upstream loose tool-card controls."
+ assert "_syncToolCallGroupSummary(state.group)" in fn, (
+ "Settled worklog groups should refresh summary state."
)
assert "data-tool-call-group" in helper, (
"Tool-call groups need a stable data-tool-call-group attribute for CSS and tests."
@@ -156,16 +241,20 @@ def test_activity_summary_keeps_header_compact_without_tool_names_or_thinking_pr
def test_live_tool_cards_use_grouping_only_when_simplified(self):
live_fn = _function_body(UI_JS, "appendLiveToolCard")
settled_fn = _function_body(UI_JS, "renderMessages")
- assert "isSimplifiedToolCalling()" in live_fn, (
- "Live streaming tool cards should branch on the Compact tool activity timeline mode."
+ assert "isSimplifiedToolCalling()" not in live_fn, (
+ "Live streaming tool cards should no longer branch on compact/timeline mode."
)
- assert "ensureActivityGroup" in live_fn, (
- "Compact live tool rendering should use the grouped activity container."
+ assert "ensureLiveWorklogContainer" in live_fn, (
+ "Live tool rendering should use the direct Worklog container."
)
- assert "toolRunningRow" in live_fn, (
- "The non-simplified live tool path should preserve the upstream running-dots row."
+ assert "ensureActivityGroup" not in live_fn, (
+ "Live tool rendering must not show the settled L1 Activity summary while streaming."
)
- assert "buildToolCard" in live_fn and "buildToolCard" in settled_fn, (
+ assert "_toolWorklogListEl(group)" in live_fn, (
+ "Live tool cards should insert into the worklog list container."
+ )
+ step_fn = _function_body(UI_JS, "_appendWorklogStep")
+ assert "buildToolCard" in live_fn and "buildToolCard" in step_fn and "_appendWorklogStep" in settled_fn, (
"Live and settled tool rendering should share buildToolCard() for consistent markup."
)
assert "data-live-tid" in live_fn, (
@@ -201,18 +290,31 @@ def test_activity_disclosure_state_is_session_and_turn_scoped(self):
assert "live:" in live_fn + thinking_fn, (
"Live Activity groups should be keyed by active stream id."
)
- assert "_copyActivityDisclosureState('live:'+streamId, 'assistant:'" in done_fn, (
- "When a live turn settles, its saved disclosure state should transfer to the persisted assistant turn."
+ assert "_copyActivityDisclosureState('live:'+streamId, 'assistant:'" not in done_fn, (
+ "Live disclosure state must not transfer to the final assistant turn; final L1 starts collapsed."
)
- def test_live_tool_activity_defaults_collapsed_unless_saved_open(self):
+ def test_live_tool_worklog_is_direct_until_settled(self):
live_fn = _function_body(UI_JS, "appendLiveToolCard")
+ live_container = _function_body(UI_JS, "ensureLiveWorklogContainer")
helper = _function_body(UI_JS, "ensureActivityGroup")
- assert "collapsed:false" not in re.sub(r"\s+", "", live_fn), (
- "Compact live tool activity should not force-open every time a chat is revisited."
+ assert "ensureLiveWorklogContainer" in live_fn, (
+ "Live tool events should append into the direct Worklog timeline."
+ )
+ assert "tool-worklog-list" in live_container and "data-live-worklog-shell" in live_container, (
+ "The direct live Worklog shell should own the L2 list without an L1 summary row."
+ )
+ assert "activity-summary" not in live_container and "tool-call-group-summary" not in live_container, (
+ "The settled Activity summary should not be present while the stream is running."
)
assert "savedState==='open'" in helper or 'savedState==="open"' in helper, (
- "A previously-open Activity group should still restore open from persisted state."
+ "Live Activity groups can still restore explicit live open state."
+ )
+ assert "if(live && savedState==='open')" in helper or 'if(live && savedState==="open")' in helper, (
+ "Saved open state must be scoped to live groups so final L1 defaults collapsed."
+ )
+ assert "savedState==='closed'" in helper or 'savedState==="closed"' in helper, (
+ "A saved closed Activity group should still override the live expanded default."
)
def test_live_activity_summary_shows_readable_progress_without_persisted_content(self):
@@ -234,30 +336,103 @@ def test_live_activity_summary_shows_readable_progress_without_persisted_content
"Readable progress must not reintroduce the noisy secondary tool-name list."
)
- def test_live_thinking_suppresses_visible_interim_echoes(self):
+ def test_terminal_worklog_titles_summarize_common_diagnostic_commands(self):
+ start = UI_JS.find("function _toolCommandTitle")
+ end = UI_JS.find("function _toolQueryTitle", start)
+ assert start != -1 and end != -1, "_toolCommandTitle() source window not found"
+ command_fn = UI_JS[start:end]
+ assert "git fetch" in command_fn and "git ahead/behind" in command_fn, (
+ "Terminal Worklog rows should distinguish common git audit commands "
+ "instead of falling back to the generic 'command' title."
+ )
+ assert "git log" in command_fn, (
+ "Commit/PR audit commands should show a git log title instead of "
+ "the generic command fallback."
+ )
+ assert "health check" in command_fn, (
+ "curl localhost /health checks should get a readable L2 title."
+ )
+ assert "process check" in command_fn and "port ${m[1]} check" in command_fn, (
+ "ps/grep and lsof diagnostics should be scannable in L2 while full "
+ "commands remain in L3 detail."
+ )
+ assert "launchctl" in command_fn, (
+ "launchd service checks should keep their service intent visible in "
+ "the Worklog row title."
+ )
+ assert "return _shortToolLabel(normalized,72);" in command_fn, (
+ "Long shell diagnostics should still expose a short L2 command "
+ "summary instead of falling back to the bare 'command' title."
+ )
+
+ def test_live_thinking_does_not_rewrite_visible_interim_echoes(self):
interim_match = re.search(r"source\.addEventListener\('interim_assistant',e=>\{(.*?)\n\s*\}\);", MESSAGES_JS, re.S)
assert interim_match, "interim_assistant listener not found"
interim_fn = interim_match.group(1)
live_thinking_fn = _function_body(MESSAGES_JS, "_liveThinkingText")
assert "visibleInterimSnippets.push(visible)" in interim_fn, (
- "Visible interim commentary should be remembered so the live Thinking card does not echo it."
+ "Visible interim commentary should remain available for process-prose boundaries."
+ )
+ assert "_stripLiveVisibleAssistantEchoFromThinking" not in live_thinking_fn, (
+ "Live Thinking should not run content-level echo suppression; the card is already low-priority Worklog detail."
+ )
+ assert "String(liveReasoningText||'').trim()" in live_thinking_fn, (
+ "Live Thinking should render the provider reasoning text as-is after normal trimming."
)
- assert "_stripLiveVisibleAssistantEchoFromThinking" in live_thinking_fn, (
- "Live Thinking text should suppress exact visible interim commentary echoes."
+
+ def test_settled_exact_duplicate_thinking_suppressed(self):
+ assert _run_thinking_echo_helper(
+ " I will check the PR status.\nThen inspect the diff. ",
+ "I will check the PR status. Then inspect the diff.",
+ "The final answer is different.",
+ ) == "", (
+ "Settled Thinking should be suppressed when normalized text exactly "
+ "matches visible process prose."
+ )
+
+ def test_genuine_reasoning_preserved_when_not_exact(self):
+ reasoning = "I need to inspect the stream state before deciding."
+ assert _run_thinking_echo_helper(
+ reasoning,
+ "I need to inspect the stream state.",
+ "The stream was running.",
+ ) == reasoning, (
+ "Non-exact reasoning should stay available as a Worklog Thinking Card."
)
+ helper = _function_body(UI_JS, "_stripVisibleAssistantEchoFromThinking")
+ assert ".split(snippet).join('')" not in helper
+ assert ".includes(" not in helper
+
+ def test_reasoning_first_interim_later_does_not_duplicate_settled_worklog(self):
+ render_fn = _function_body(UI_JS, "renderMessages")
+ helper = _function_body(UI_JS, "_worklogReasoningTextFromMessage")
+ assert "assistantTurnFinalVisibleContentByRawIdx" in render_fn, (
+ "renderMessages must compute current assistant-turn final text so "
+ "reasoning-first/interim-later turns can be compared at settlement."
+ )
+ assert "assistantTurnVisibleContentByRawIdx" in render_fn, (
+ "If done-time reasoning is attached to the final assistant message, "
+ "settlement must still compare against earlier visible process prose "
+ "from the same assistant turn."
+ )
+ assert "_worklogReasoningTextFromMessage(m, rawIdx, toolCallAssistantIdxs, displayContent, turnFinalVisibleContent, turnVisibleContents)" in render_fn
+ assert "_stripVisibleAssistantEchoFromThinking(thinkingText, visibleContent, turnFinalVisibleContent, ...visibleTexts)" in helper
+ assert _run_thinking_echo_helper(
+ "I am checking the 3401 review blocker.",
+ "I am checking the 3401 review blocker.",
+ "Conclusion: Thinking dedupe needs a small fix.",
+ ) == ""
- def test_settled_thinking_suppresses_visible_assistant_echoes(self):
+ def test_settled_thinking_uses_exact_dedupe_not_live_rewrite(self):
render_fn = _function_body(UI_JS, "renderMessages")
helper = _function_body(UI_JS, "_stripVisibleAssistantEchoFromThinking")
- assert "_stripVisibleAssistantEchoFromThinking(thinkingText, displayContent)" in render_fn, (
- "Settled Thinking cards should not repeat text already rendered as visible assistant content."
+ assert "_stripVisibleAssistantEchoFromThinking(thinkingText, displayContent)" not in render_fn, (
+ "Settled Thinking dedupe needs process prose plus turn-final answer, "
+ "not the old single visible-text input."
)
- assert "s.length>=20" in helper, (
- "Thinking echo suppression should ignore tiny snippets to avoid over-stripping reasoning."
- )
- assert "out.split(snippet).join('')" in helper, (
- "Thinking echo suppression should remove exact visible assistant snippets from reasoning display."
+ assert "_normalizeThinkingEchoCompare" in helper and "visibleNorm===thinkingNorm" in helper, (
+ "Settled Thinking dedupe must be exact / normalized-exact only."
)
def test_compact_activity_keeps_thinking_cards_after_session_switch(self):
@@ -270,20 +445,26 @@ def test_compact_activity_keeps_thinking_cards_after_session_switch(self):
)
render_fn = _function_body(UI_JS, "renderMessages")
assert "isSimplifiedToolCalling()" in render_fn and "assistantThinking.set(rawIdx, thinkingText)" in render_fn, (
- "Compact settled transcript rendering should preserve Thinking cards after switching sessions."
+ "Compact settled transcript rendering should keep reasoning metadata available without promoting it to visible prose."
+ )
+ helper = _function_body(UI_JS, "_worklogReasoningTextFromMessage")
+ assert "_assistantReasoningPayloadText(m)" in helper and "_stripVisibleAssistantEchoFromThinking" in helper, (
+ "Provider reasoning metadata should feed a sanitized Worklog Thinking Card "
+ "after settled exact-duplicate suppression."
+ )
+ assert "data-worklog-thinking-card" in UI_JS, (
+ "Thinking should be an explicit Worklog item, independent from Tool Cards."
)
- # #3709: the Activity disclosure now renders the TURN's merged thinking
- # (mergedThinking — all of a turn's thinking de-duped, incl. a suppressed
- # thinking-only sibling) rather than a single message's entry. Same node,
- # same Activity body — only the source variable changed.
- assert "_thinkingActivityNode(mergedThinking, false)" in render_fn, (
- "Settled Thinking cards should render inside the compact Activity disclosure."
+ render_min = re.sub(r"\s+", "", render_fn)
+ assert "thinkingKey:thinkingText?`thinking:${_normalizeThinkingEchoCompare(thinkingText)}`:''" in render_min, (
+ "Settled Worklog should key Thinking Cards by normalized content so exact duplicate "
+ "Thinking from sibling messages does not render twice."
)
- assert "body.appendChild(_thinkingActivityNode(mergedThinking, false))" in render_fn, (
- "Settled Thinking cards should stay inside the same Activity body as the related tools."
+ assert "_appendWorklogStep" in render_fn, (
+ "Visible assistant anchors, Thinking Cards, and tools should still build the compact Worklog disclosure."
)
- assert ".agent-activity-thinking:not([data-live-thinking=\"1\"])" in render_fn, (
- "Settled rerenders must remove previously inserted Thinking activity rows before rebuilding."
+ assert ".wl-reason[data-worklog-reason-source=\"reasoning\"]" in render_fn, (
+ "Settled rerenders must remove previously inserted reasoning Worklog rows before rebuilding."
)
assert "seg.insertAdjacentHTML('beforeend', _thinkingCardHtml(thinkingText))" in render_fn, (
"The non-simplified path should preserve standalone settled thinking cards."
@@ -293,17 +474,17 @@ def test_live_visible_interim_text_preserves_timeline_boundary(self):
live_thinking_fn = _function_body(UI_JS, "appendThinking")
live_tool_fn = _function_body(UI_JS, "appendLiveToolCard")
helper = _function_body(UI_JS, "ensureActivityGroup")
- assert "isSimplifiedToolCalling()" in live_thinking_fn, (
- "Live thinking should branch on the Compact tool activity toggle."
+ assert "_worklogReasonNodeFromText(thinkingText" not in live_thinking_fn, (
+ "Provider reasoning should not render as live Worklog process prose."
)
- assert "_thinkingActivityNode(thinkingText, false)" in live_thinking_fn, (
- "Compact live thinking should render inside the Activity disclosure."
+ assert "_thinkingActivityNode(clean, false)" in live_thinking_fn and "data-live-thinking" in live_thinking_fn, (
+ "Live provider thinking should render as a collapsed Worklog Thinking Card."
)
- assert "ensureActivityGroup(blocks,{live:true" in live_thinking_fn and "body.appendChild(row)" in live_thinking_fn, (
- "Compact live thinking should share the same Activity body as live tool cards."
+ assert "ensureLiveWorklogContainer" in live_thinking_fn, (
+ "Live Thinking Cards should use the shared Worklog container, not a Tool Card group."
)
assert "removeAttribute('data-live-activity-current')" not in live_thinking_fn, (
- "Reasoning/Thinking updates alone should not split consecutive tools into one-tool Activity rows."
+ "Reasoning/Thinking updates alone should not split consecutive tools into one-tool Worklog rows."
)
assert '.tool-call-group[data-live-tool-call-group="1"][data-live-activity-current="1"]' in helper, (
"Live tool cards should only reuse the current Activity burst, not the first group in the turn."
@@ -311,15 +492,15 @@ def test_live_visible_interim_text_preserves_timeline_boundary(self):
assert "group.setAttribute('data-live-activity-current','1')" in helper, (
"New live Activity bursts must be marked current so later tools append to the right group."
)
- assert "body.querySelector" in live_tool_fn and "data-live-tid" in live_tool_fn, (
+ assert "querySelector" in live_tool_fn and "data-live-tid" in live_tool_fn, (
"tool_complete must still update its current live Activity burst by tool id."
)
finalize_fn = _function_body(UI_JS, "finalizeThinkingCard")
- assert "turn.querySelector('.agent-activity-thinking[data-thinking-active=\"1\"]')" in finalize_fn, (
- "Compact Thinking cards live inside the assistant turn, so finalization must clear the active marker from the whole turn."
+ assert "turn.querySelector('.wl-reason[data-worklog-reason-active=\"1\"]')" in finalize_fn, (
+ "Finalization should still clean up any legacy active reasoning marker."
)
- assert "body.querySelector('.agent-activity-thinking[data-thinking-active=\"1\"]')" in live_thinking_fn and "setAttribute('data-thinking-active','1')" in live_thinking_fn, (
- "Compact live thinking should reactivate the latest existing Thinking card instead of stacking a new card after every tool boundary."
+ assert "data-worklog-reason-active" not in live_thinking_fn, (
+ "New live reasoning text should not create active Worklog prose rows."
)
reset_fn = _function_body(MESSAGES_JS, "_resetAssistantSegment")
assert "function closeCurrentLiveActivityGroup()" in UI_JS, (
@@ -347,6 +528,41 @@ def test_live_visible_interim_text_preserves_timeline_boundary(self):
"Tool starts must not split consecutive tools into one-tool Activity rows."
)
+ def test_live_thinking_card_is_segment_scoped_not_global_singleton(self):
+ live_thinking_fn = _function_body(UI_JS, "appendThinking")
+ placement_fn = _function_body(MESSAGES_JS, "_liveThinkingPlacement")
+ update_fn = _function_body(MESSAGES_JS, "_updateLiveThinkingCard")
+ interim_match = re.search(r"source\.addEventListener\('interim_assistant',e=>\{(.*?)\n\s*\}\);", MESSAGES_JS, re.S)
+ assert interim_match, "interim_assistant listener not found"
+ interim_fn = interim_match.group(1)
+
+ assert "data-live-thinking-key" in live_thinking_fn, (
+ "Live Thinking rows need a segment/burst key so later reasoning does not update "
+ "the first Thinking Card in the turn."
+ )
+ assert 'data-live-thinking="1"][data-live-thinking-key="' in live_thinking_fn, (
+ "appendThinking() must query the current segment's live Thinking Card, not a "
+ "turn-global singleton."
+ )
+ assert "segmentSeq" in placement_fn and "_currentLiveSegmentSeq" in placement_fn, (
+ "Thinking placement should reuse the live segment sequence instead of inventing "
+ "a second placement model."
+ )
+ assert "burstId:_currentActivityBurstId" in placement_fn, (
+ "Thinking placement should carry the current activity burst for Worklog ordering."
+ )
+ assert "updateThinking(text, opts)" in update_fn, (
+ "messages.js should pass segment placement into the UI Thinking helper."
+ )
+ assert "updateThinking('')" not in interim_fn, (
+ "Live interim boundaries should finalize the current Thinking Card instead of "
+ "clearing it mid-stream."
+ )
+ assert "finalizeThinkingCard()" in interim_fn, (
+ "Visible interim assistant progress must close the current Thinking segment "
+ "before the next segment starts."
+ )
+
def test_live_compression_card_splits_current_tool_activity_burst(self):
compression_fn = _function_body(UI_JS, "appendLiveCompressionCard")
close_fn = _function_body(UI_JS, "closeCurrentLiveActivityGroup")
@@ -415,28 +631,67 @@ def test_default_skin_preview_stays_upstream(self):
def test_tool_card_css_uses_design_tokens_for_chrome(self):
css_min = re.sub(r"\s+", "", CSS)
assert ".tool-card{" in css_min, ".tool-card rule missing"
- assert "border-radius:var(--radius-card)" in css_min, (
- ".tool-card border radius should use --radius-card, not hardcoded px."
- )
- assert "background:var(--surface-subtle)" in css_min, (
- ".tool-card background should use --surface-subtle."
- )
- assert "border:1pxsolidvar(--border-subtle)" in css_min, (
- ".tool-card border should use --border-subtle."
+ tool_card_rule = css_min.rsplit(".tool-card{", 1)[1].split("}", 1)[0]
+ rows_rule = css_min.split(".tg-rows{", 1)[1].split("}", 1)[0]
+ assert "background:transparent" in tool_card_rule
+ assert "border:0" in tool_card_rule
+ assert "border-left:0" in tool_card_rule
+ assert "border-left:1pxsolidvar(--border-subtle)" in rows_rule, (
+ "Nested tool groups should be expressed with only a subtle left guide line."
)
def test_tool_card_header_and_text_use_spacing_and_font_tokens(self):
css_min = re.sub(r"\s+", "", CSS)
assert ".tool-card-header{" in css_min, ".tool-card-header rule missing"
- assert "gap:var(--space-2)" in css_min, (
- ".tool-card-header gap should use --space-2."
- )
- assert "padding:var(--space-1)var(--space-3)" in css_min, (
- ".tool-card-header padding should use spacing tokens."
- )
- assert ".tool-card-name{" in css_min and "font-size:var(--font-size-xs)" in css_min, (
- ".tool-card-name should use --font-size-xs."
- )
- assert ".tool-card-preview{" in css_min and "font-size:var(--font-size-xs)" in css_min, (
- ".tool-card-preview should use --font-size-xs."
+ header_rule = css_min.rsplit(".tool-card-header{", 1)[1].split("}", 1)[0]
+ title_rule = css_min.split(".tl-title{", 1)[1].split("}", 1)[0]
+ assert "gap:7px" in header_rule
+ assert "padding:3px8px" in header_rule
+ assert "border-radius:7px" in header_rule
+ assert ".tool-card-name{" in css_min and "font-size:var(--message-body-font-size)" in css_min
+ assert "font-size:var(--message-body-font-size)" in title_rule
+ assert "font-family:var(--font-mono)" in title_rule
+
+ def test_worklog_thinking_card_uses_quiet_tool_row_hierarchy(self):
+ selector = ".tool-worklog-list > .agent-activity-thinking .thinking-card,"
+ assert selector in CSS, "Worklog Thinking Card quiet override missing"
+ card_rule = re.sub(r"\s+", "", CSS.split(selector, 1)[1].split("}", 1)[0])
+ header_rule = re.sub(
+ r"\s+",
+ "",
+ CSS.split(".tool-worklog-list > .agent-activity-thinking .thinking-card-header{", 1)[1].split("}", 1)[0],
+ )
+ label_rule = re.sub(
+ r"\s+",
+ "",
+ CSS.split(".tool-worklog-list > .agent-activity-thinking .thinking-card-label{", 1)[1].split("}", 1)[0],
+ )
+ icon_rule = re.sub(
+ r"\s+",
+ "",
+ CSS.split(".tool-worklog-list > .agent-activity-thinking .thinking-card-icon,", 1)[1].split("}", 1)[0],
+ )
+ body_rule = re.sub(
+ r"\s+",
+ "",
+ CSS.split(".tool-worklog-list > .agent-activity-thinking .thinking-card.open .thinking-card-body{", 1)[1].split("}", 1)[0],
+ )
+ pre_rule = re.sub(
+ r"\s+",
+ "",
+ CSS.split(".tool-worklog-list > .agent-activity-thinking .thinking-card-body pre{", 1)[1].split("}", 1)[0],
)
+
+ assert "background:transparent" in card_rule
+ assert "border:0" in card_rule
+ assert "border-radius:0" in card_rule
+ assert "display:flex" in header_rule and "align-items:center" in header_rule
+ assert "color:var(--muted)" in header_rule
+ assert "font-size:var(--message-body-font-size)" in header_rule
+ assert "font-weight:400" in header_rule
+ assert "font-weight:400" in label_rule
+ assert "letter-spacing:0" in label_rule
+ assert "color:var(--muted)" in icon_rule
+ assert "padding:6px8px7px8px" in body_rule
+ assert "font-size:var(--message-body-font-size)" in pre_rule
+ assert "line-height:var(--message-body-line-height)" in pre_rule
diff --git a/tests/test_webui_gateway_chat_backend.py b/tests/test_webui_gateway_chat_backend.py
index cd78789a36..364472da4b 100644
--- a/tests/test_webui_gateway_chat_backend.py
+++ b/tests/test_webui_gateway_chat_backend.py
@@ -315,6 +315,7 @@ def fake_urlopen(req, timeout=0):
events = []
while not subscriber.empty():
events.append(subscriber.get_nowait())
+ event_pairs = [(item[0], item[1]) for item in events]
assert ("tool", {
"event_type": "tool.started",
"name": "terminal",
@@ -322,7 +323,7 @@ def fake_urlopen(req, timeout=0):
"args": {},
"is_error": False,
"tid": "call-1",
- }) in events
+ }) in event_pairs
assert ("tool_complete", {
"event_type": "tool.completed",
"name": "terminal",
@@ -330,7 +331,8 @@ def fake_urlopen(req, timeout=0):
"args": {},
"is_error": False,
"tid": "call-1",
- }) in events
+ }) in event_pairs
+ assert all(len(item) == 3 and item[2] for item in events)
def test_gateway_chat_worker_normalizes_prefill_slice_before_system_prefix(tmp_path, monkeypatch):