cli-jaw 2.17.38 → 2.17.39

package/public/js/features/message-history.ts

@@ -21,7 +21,19 @@ import { normalizeMessageToolLog, parseToolLog, toProcessSteps, type MessageItem
 import { canFollowAfterRestore, ensureScrollTracking, markFollowingBottom, settleChatBottomAfterInitialLoad } from './chat-scroll.js';
 import { updateStatMsgs } from './ui-status.js';
 import { seedCompletedElicitationsFromMessages } from './elicitation-state.js';
-import { withCurrentSessionQuery } from './session-hub.js';
+import { withCurrentSessionQuery, currentSessionId } from './session-hub.js';
+import { remountLiveActivity, recycleActivityHost } from './activity-live.js';
+import { prepareActivityTranscript, setActivityTranscript, observeActivityHistory, recycleActivityHistory } from './activity-history.js';
+
+const activityVirtualHooks = {
+    postRender(root: HTMLElement) { remountLiveActivity(root); observeActivityHistory(root); },
+    recycle(message: HTMLElement) { recycleActivityHistory(message); recycleActivityHost(message); },
+};
+
+/** Live promotion may bypass history bootstrap; preserve every installed callback. */
+export function ensureActivityVirtualCallbacks(vs: ReturnType<typeof getVirtualScroll>): void {
+    vs.addLifecycleHooks(activityVirtualHooks);
+}
 
 export function buildVirtualHistoryItems(msgs: MessageItem[]): VirtualItem[] {
     return msgs.map((m, index) => buildLazyVirtualMessageItem(normalizeMessageToolLog(m), index));
@@ -70,7 +82,7 @@ function readWorkingDirFromScope(scope: string): string | null {
 }
 
 export function registerVirtualScrollCallbacks(vs: ReturnType<typeof getVirtualScroll>): void {
-    vs.onLazyRender = (targets: HTMLElement[]) => {
+    vs.onLazyRender ??= (targets: HTMLElement[]) => {
         for (const el of targets) {
             if (!el.classList.contains('lazy-pending')) continue;
             const raw = el.getAttribute('data-raw') || '';
@@ -97,7 +109,7 @@ export function registerVirtualScrollCallbacks(vs: ReturnType<typeof getVirtualS
             void renderMermaidBlocks(el, { immediate: true });
         }
     };
-    vs.onPostRender = (viewport: HTMLElement) => {
+    vs.onPostRender ??= (viewport: HTMLElement) => {
         activateWidgets(viewport);
         hydrateElicitationBlocks(viewport);
         hydrateSearchResultsBlocks(viewport);
@@ -108,6 +120,7 @@ export function registerVirtualScrollCallbacks(vs: ReturnType<typeof getVirtualS
         void linkifyFilePathsWithNotesRoot(viewport);
         void renderMermaidBlocks(viewport, { immediate: true });
     };
+    ensureActivityVirtualCallbacks(vs);
 }
 
 export function makeBootstrapDeps(
@@ -134,6 +147,12 @@ export function makeBootstrapDeps(
 function hydrateSmallHistory(messages: MessageItem[]): void {
     messages.forEach(m => {
         const div = addMessage(m.role === 'assistant' ? 'agent' : m.role, m.content, m.cli);
+        if (m.id !== undefined) div.dataset['messageId'] = String(m.id);
+        if (m.trace_run_id) div.dataset['traceRunId'] = m.trace_run_id;
+        if (m.session_id !== undefined) div.dataset['messageSessionId'] = m.session_id;
+        if (m.server_message_id !== undefined) {
+            div.dataset['serverMessageId'] = String(m.server_message_id); div.dataset['activitySaved'] = 'true';
+        }
         if (m.role === 'assistant' && m.tool_log) {
             const tools = parseToolLog(m.tool_log);
             if (tools.length > 0) {
@@ -156,6 +175,10 @@ function cachedToMessage(message: CachedMessage): MessageItem {
         content: message.content,
         cli: message.cli ?? null,
         tool_log: message.tool_log ?? null,
+        trace_run_id: message.trace_run_id ?? null,
+        ...(message.session_id === undefined ? {} : { session_id: message.session_id }),
+        ...(typeof message.message_id === 'number' && Number.isSafeInteger(message.message_id) && message.message_id > 0
+            ? { server_message_id: message.message_id } : {}),
     };
 }
 
@@ -174,13 +197,39 @@ function historySignature(scope: string, msgs: MessageItem[]): string {
 // Without single-flight they both clear+bootstrap the virtual scroll and the
 // newest rows can stay lazy-pending. Concurrent callers join the same load.
 let loadMessagesInFlight: Promise<void> | null = null;
+let loadMessagesKey = '', loadGeneration = 0;
+let loadController: AbortController | null = null;
+let renderedView = '', renderedSession: string | null = null;
+let renderedRuns = new Set<string>();
 
 export async function loadMessages(): Promise<void> {
-    if (loadMessagesInFlight) return loadMessagesInFlight;
-    loadMessagesInFlight = loadMessagesOnce().finally(() => {
-        loadMessagesInFlight = null;
+    const requestedSession = currentSessionId();
+    const key = `${readCurrentMessageLocationKey()}:${requestedSession ?? ''}`;
+    if (loadMessagesKey === key) {
+        if (loadMessagesInFlight) return loadMessagesInFlight;
+    }
+    loadController?.abort(); const controller = new AbortController(); loadController = controller;
+    loadMessagesKey = key; const generation = ++loadGeneration;
+    const path = `/api/messages${bootMessageQuery()}&withSession=1`;
+    prepareActivityTranscript();
+    const timer = setTimeout(() => controller.abort(new DOMException('Message history deadline', 'TimeoutError')), 30_000);
+    const current = () => generation === loadGeneration
+        && key === `${readCurrentMessageLocationKey()}:${currentSessionId() ?? ''}`;
+    const work = loadMessagesOnce({ requestedSession, key, path, signal: controller.signal,
+        current: () => !controller.signal.aborted && current(),
+    }).catch(error => {
+        if (!controller.signal.aborted) throw error;
+    }).finally(() => {
+        clearTimeout(timer);
+        if (loadMessagesInFlight === work) { loadMessagesInFlight = null; loadController = null; }
+        // Release only this view's suspension; an older cancellation cannot resume
+        // a newer load or grant identity to an unverified cache result.
+        if (controller.signal.aborted && current()) {
+            setActivityTranscript(renderedView === key ? renderedSession : null,
+                renderedView === key ? renderedRuns : new Set());
+        }
     });
-    return loadMessagesInFlight;
+    loadMessagesInFlight = work; return work;
 }
 
 /** True while a history snapshot fetch/rebuild is mid-flight. A live append
@@ -192,32 +241,100 @@ export function historyReloadInFlight(): boolean {
     return loadMessagesInFlight !== null;
 }
 
-async function loadMessagesOnce(): Promise<void> {
+interface MessageReadContext {
+    requestedSession: string | null; key: string; path: string; signal: AbortSignal; current(): boolean;
+}
+
+/** HTTP and IndexedDB share the loader's deadline, even when a source ignores abort. */
+async function readMessageSource<T>(read: () => Promise<T>, signal: AbortSignal): Promise<T> {
+    signal.throwIfAborted();
+    let abort!: () => void;
+    const cancelled = new Promise<never>((_resolve, reject) => {
+        abort = () => reject(signal.reason); signal.addEventListener('abort', abort, { once: true });
+    });
+    try { return await Promise.race([read(), cancelled]); }
+    finally { signal.removeEventListener('abort', abort); }
+}
+
+function parseMessageSnapshot(raw: unknown, requested: string | null): { sessionId: string | null; messages: MessageItem[] } {
+    let sessionId = requested, rows: unknown;
+    if (Array.isArray(raw)) rows = raw; // Older server: explicit requested session only.
+    else if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+        const value = raw as Record<string, unknown>;
+        if (typeof value['sessionId'] !== 'string' || !value['sessionId'] || value['sessionId'].length > 240
+            || requested !== null && value['sessionId'] !== requested) throw new Error('message_session_mismatch');
+        sessionId = value['sessionId']; rows = value['messages'];
+    }
+    if (!Array.isArray(rows)) throw new Error('invalid_message_snapshot');
+    const messages = rows.slice(-BOOT_MESSAGE_WINDOW).map((value: unknown) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid_message_snapshot');
+        const record = value as Record<string, unknown>;
+        if (typeof record['role'] !== 'string' || typeof record['content'] !== 'string'
+            || (record['id'] !== undefined && !(typeof record['id'] === 'number' && Number.isSafeInteger(record['id']) && record['id'] > 0)
+                && !(typeof record['id'] === 'string' && record['id'].length <= 240))
+            || (record['trace_run_id'] != null && !(typeof record['trace_run_id'] === 'string' && record['trace_run_id'].length <= 240))
+            || (record['session_id'] !== undefined && !(typeof record['session_id'] === 'string' && record['session_id'].length > 0 && record['session_id'].length <= 240))
+            || (sessionId && record['session_id'] !== undefined && record['session_id'] !== sessionId)
+            || (record['cli'] != null && typeof record['cli'] !== 'string')
+            || (record['tool_log'] != null && typeof record['tool_log'] !== 'string')) throw new Error('invalid_message_snapshot');
+        const row = record as unknown as MessageItem;
+        const normalized: MessageItem = { ...row, ...(sessionId === null ? {} : { session_id: sessionId }) };
+        // Derive only from the actual API row, not a supplied helper field or IDB id.
+        delete normalized.server_message_id;
+        if (typeof row.id === 'number') normalized.server_message_id = row.id;
+        return normalizeMessageToolLog(normalized);
+    });
+    return { sessionId, messages };
+}
+
+function legacyCachePreview(messages: CachedMessage[]): void {
+    if (!messages.length) return;
+    const box = document.createElement('details'); box.className = 'activity-legacy-cache';
+    const title = document.createElement('summary'); title.textContent = 'Unverified legacy cache preview';
+    const notice = document.createElement('p');
+    notice.textContent = 'This limited cache preview has no verified conversation identity. Connect to refresh; it cannot load Activity history.';
+    const text = document.createElement('pre');
+    text.textContent = messages.slice(-40).map(message => message.content.slice(0, 1000)).join('\n\n');
+    box.append(title, notice, text); chatContainer()?.append(box);
+}
+const chatContainer = () => document.getElementById('chatMessages');
+
+async function loadMessagesOnce(context: MessageReadContext): Promise<void> {
     const vs = getVirtualScroll();
     const chatEl = document.getElementById('chatMessages');
     const previousScope = getMessageScope();
     const locationKey = readCurrentMessageLocationKey();
     let workingDir = readWorkingDirFromScope(previousScope);
     try {
-        const settings = await api<{ workingDir?: string }>('/api/settings');
+        const settings = await readMessageSource(() => api<{ workingDir?: string }>('/api/settings', { signal: context.signal }), context.signal);
         if (settings?.workingDir) workingDir = settings.workingDir;
     } catch { /* localStorage fallback already initialized currentScope */ }
+    if (!context.current()) return;
     const nextScope = buildMessageScopeIdentity({ locationKey, workingDir });
     setMessageScope(nextScope);
     const scopeChanged = nextScope !== previousScope;
-    const msgs = await api<MessageItem[]>(`/api/messages${bootMessageQuery()}`);
-    if (msgs !== null) {
-        const safeMsgs = msgs.map(normalizeMessageToolLog);
+    let snapshot: ReturnType<typeof parseMessageSnapshot> | null = null;
+    try {
+        const raw = await readMessageSource(() => api<unknown>(context.path, { signal: context.signal }), context.signal);
+        if (raw !== null) snapshot = parseMessageSnapshot(raw, context.requestedSession);
+    } catch (error) { if (context.current()) console.warn('[history] message snapshot unavailable', error); }
+    if (!context.current()) return;
+    if (snapshot) {
+        const safeMsgs = snapshot.messages;
         seedCompletedElicitationsFromMessages(safeMsgs);
         const hadRenderedHistory = Boolean(chatEl?.querySelector('.msg')) || vs.active;
-        const signature = historySignature(nextScope, safeMsgs);
+        const signature = historySignature(`${nextScope}:${snapshot.sessionId ?? ''}`, safeMsgs);
+        renderedView = context.key; renderedSession = snapshot.sessionId;
+        renderedRuns = new Set(safeMsgs.filter(message => message.role === 'assistant' && message.trace_run_id).map(message => message.trace_run_id!));
         if (hadRenderedHistory && !scopeChanged && signature === lastRenderedSignature) {
             updateStatMsgs(safeMsgs.length);
+            setActivityTranscript(renderedSession, renderedRuns);
             return; // identical history — keep the live DOM and scroll state
         }
         lastRenderedSignature = signature;
         const shouldForceBottom = scopeChanged || !hadRenderedHistory;
         const savedIndex = !shouldForceBottom && vs.active ? vs.firstVisibleIndex() : null;
+        if (chatEl) recycleActivityHistory(chatEl);
         vs.clear();
         if (chatEl) chatEl.innerHTML = '';
         if (safeMsgs.length >= VS_THRESHOLD) {
@@ -232,16 +349,23 @@ async function loadMessagesOnce(): Promise<void> {
         cacheMessages(safeMsgs.map(m => ({
             ...(m.id !== undefined ? { message_id: m.id } : {}),
             role: m.role, content: m.content, cli: m.cli ?? null, tool_log: m.tool_log ?? null, timestamp: Date.now(),
-        }))).catch(() => {});
+            trace_run_id: m.trace_run_id ?? null, ...(m.session_id === undefined ? {} : { session_id: m.session_id }),
+        })), nextScope).catch(() => {});
+        setActivityTranscript(renderedSession, renderedRuns);
         updateStatMsgs(safeMsgs.length);
         showEmptyState();
         return;
     }
-    if (chatEl && chatEl.children.length > 0) {
+    if (chatEl && chatEl.children.length > 0 && renderedView === context.key) {
+        setActivityTranscript(renderedSession, renderedRuns);
         showEmptyState();
         return;
     }
-    const cached = await getScopedMessages();
+    if (chatEl && renderedView !== context.key) { recycleActivityHistory(chatEl); vs.clear(); chatEl.replaceChildren(); }
+    const allCached = await readMessageSource(() => getScopedMessages(nextScope), context.signal);
+    if (!context.current()) return;
+    const cached = (context.requestedSession === null ? allCached
+        : allCached.filter(message => message.session_id === context.requestedSession)).slice(-BOOT_MESSAGE_WINDOW);
     if (cached.length > 0) {
         const safeCached = cached.map(cachedToMessage).map(normalizeMessageToolLog);
         seedCompletedElicitationsFromMessages(safeCached);
@@ -256,5 +380,9 @@ async function loadMessagesOnce(): Promise<void> {
         addSystemMsg(`${ICONS.warning} ${t('ui.offline.banner')}`);
         updateStatMsgs(safeCached.length);
     }
+    if (context.requestedSession !== null) legacyCachePreview(allCached.filter(message => message.session_id === undefined));
+    renderedView = context.key; renderedSession = context.requestedSession;
+    renderedRuns = new Set(cached.filter(message => message.role === 'assistant' && message.trace_run_id).map(message => message.trace_run_id!));
+    setActivityTranscript(renderedSession, renderedRuns);
     showEmptyState();
 }

package/public/js/features/message-item-html.ts

@@ -16,6 +16,10 @@ export function buildLazyVirtualMessageItem(m: MessageItem, index: number): Virt
     const role = m.role === 'assistant' ? 'agent' : m.role;
     const messageId = String(m.id ?? generateId());
     const sourceAttrs = messageSourceAttributes({ role, messageId, turnIndex: index });
+    const traceAttr = m.trace_run_id ? ` data-trace-run-id="${escapeHtml(m.trace_run_id)}"` : '';
+    const sessionAttr = m.session_id === undefined ? '' : ` data-message-session-id="${escapeHtml(m.session_id)}"`;
+    const savedAttr = m.server_message_id === undefined ? ''
+        : ` data-server-message-id="${escapeHtml(String(m.server_message_id))}" data-activity-saved="true"`;
     const rawContent = stripOrchestration(
         role === 'user' ? formatUserPrompt(m.content) : m.content,
     );
@@ -30,7 +34,7 @@ export function buildLazyVirtualMessageItem(m: MessageItem, index: number): Virt
     // Keep .msg-user for boundary semantics; modifier slims the visual (see chat-messages.ts).
     const goalBoundaryClass = role === 'user' && m.cli === 'goal_continuation' ? ' msg-goal-boundary' : '';
     const html = role === 'agent'
-        ? `<div class="msg msg-agent" ${sourceAttrs}><div class="agent-icon" aria-hidden="true">${getAgentIcon(m.cli)}</div><div class="agent-body"${toolAttr}>${contentHtml}${actions}</div></div>`
-        : `<div class="msg msg-${role}${goalBoundaryClass}" ${sourceAttrs}><div class="user-body"><div class="msg-label">${label}</div>${contentHtml}${actions}</div><div class="user-icon" aria-hidden="true">${getUserAvatarMarkup()}</div></div>`;
-    return { id: generateId(), html, height: 80, rehydratesProcessDetails: Boolean(rawToolLog) };
+        ? `<div class="msg msg-agent" ${sourceAttrs}${traceAttr}${sessionAttr}${savedAttr}><div class="agent-icon" aria-hidden="true">${getAgentIcon(m.cli)}</div><div class="agent-body"${toolAttr}>${contentHtml}${actions}</div></div>`
+        : `<div class="msg msg-${role}${goalBoundaryClass}" ${sourceAttrs}${sessionAttr}${savedAttr}><div class="user-body"><div class="msg-label">${label}</div>${contentHtml}${actions}</div><div class="user-icon" aria-hidden="true">${getUserAvatarMarkup()}</div></div>`;
+    return { id: generateId(), messageId, html, height: 80, rehydratesProcessDetails: Boolean(rawToolLog) };
 }

package/public/js/features/native-request-bridge.ts

@@ -0,0 +1,133 @@
+import { parseActivityIdentity, type ActivityIdentity } from '../../../src/shared/presentation.js';
+import { parseRuntimeEvent } from '../../../src/shared/runtime-event-parse.js';
+import { parseRuntimeRequestNotice, RUNTIME_REQUEST_NOTICE_EVENT } from '../../../src/shared/runtime-request-notice.js';
+import { state } from '../state.js';
+import { withCurrentSessionQuery } from './session-hub.js';
+import { mountNativeRequests, type NativeRequestHealth } from './native-requests.js';
+
+interface BridgeOptions {
+    host(): HTMLElement | null;
+    refreshSnapshot(): Promise<void>;
+}
+type Panel = ReturnType<typeof mountNativeRequests>;
+
+/** SSE health is not REST freshness. This bridge never submits responses. */
+export function createNativeRequestBridge(options: BridgeOptions) {
+    let health: NativeRequestHealth = 'unknown';
+    let epoch = 0, snapshotGeneration = 0;
+    let identity: ActivityIdentity | null = null;
+    let identityPath = '';
+    let panel: Panel | null = null;
+    let recovery: HTMLElement | null = null;
+    let queued = false;
+    let manualRequest: { epoch: number; path: string; panel: Panel | null } | null = null;
+    const snapshotPath = () => withCurrentSessionQuery('/api/orchestrate/snapshot');
+    const same = (other: ActivityIdentity) => identity?.sessionId === other.sessionId && identity.scope === other.scope;
+
+    function showRecovery(message: string): void {
+        const host = options.host();
+        if (!host || panel) return;
+        if (!recovery) {
+            const doc = host.ownerDocument;
+            recovery = doc.createElement('section'); recovery.className = 'native-requests';
+            recovery.setAttribute('aria-label', 'Live runtime requests');
+            const status = doc.createElement('p'); status.className = 'native-request-status';
+            status.setAttribute('role', 'status');
+            const retry = doc.createElement('button'); retry.type = 'button'; retry.textContent = 'Refresh requests';
+            retry.addEventListener('click', () => { void manualRefresh(); });
+            recovery.append(status, retry);
+            const input = [...host.children].find(child => child.classList.contains('chat-input-area'));
+            host.insertBefore(recovery, input ?? null);
+        }
+        recovery.querySelector('p')!.textContent = message;
+    }
+
+    function forget(): void {
+        panel?.dispose(); panel = null;
+        identity = null; state.activityIdentity = null;
+    }
+
+    function scheduleRefresh(): void {
+        if (queued || health !== 'healthy' || !panel || (manualRequest?.epoch === epoch
+            && manualRequest.path === identityPath && (!manualRequest.panel || manualRequest.panel === panel))) return;
+        queued = true;
+        const ownEpoch = epoch;
+        queueMicrotask(() => {
+            queued = false;
+            if (ownEpoch === epoch && health === 'healthy' && identityPath === snapshotPath()) void panel?.refresh('auto');
+        });
+    }
+
+    async function manualRefresh(): Promise<void> {
+        if (manualRequest?.epoch === epoch && manualRequest.path === snapshotPath() && manualRequest.panel === panel) return;
+        const own = { epoch, path: snapshotPath(), panel }; manualRequest = own;
+        try {
+            if (!panel || identityPath !== snapshotPath()) await options.refreshSnapshot();
+            if (own.epoch === epoch && own.path === snapshotPath() && identityPath === own.path
+                && (!own.panel || own.panel === panel)) await panel?.refresh('manual');
+        } catch {
+            showRecovery('Request identity could not be loaded. Refresh requests to retry.');
+        } finally { if (manualRequest === own) manualRequest = null; }
+    }
+
+    function changeHealth(next: NativeRequestHealth): void {
+        health = next; ++epoch;
+        panel?.setStreamHealth(next);
+        showRecovery(next === 'healthy' ? 'Loading request identity.'
+            : 'Live request updates unavailable. Refresh requests to check pending requests manually.');
+    }
+
+    return {
+        channelChanged() { changeHealth('unknown'); },
+        unavailable() { changeHealth('unavailable'); },
+        sseOpened() { changeHealth('healthy'); },
+        invalidateIdentity() {
+            ++epoch; ++snapshotGeneration; forget();
+            showRecovery('Request identity changed. Refresh requests to check this conversation.');
+        },
+        /** Guard the entire snapshot application, not just the new identity field. */
+        beginSnapshot() {
+            const path = snapshotPath();
+            if (identityPath && identityPath !== path) forget();
+            const ownEpoch = epoch, generation = ++snapshotGeneration;
+            const isCurrent = () => ownEpoch === epoch && generation === snapshotGeneration && path === snapshotPath();
+            return {
+                path, isCurrent,
+                accept(value: unknown) {
+                    if (!isCurrent()) return;
+                    const next = parseActivityIdentity(value);
+                    if (!next) { forget(); showRecovery('Request identity unavailable. Refresh requests to retry.'); return; }
+                    if (!same(next)) {
+                        forget(); identity = next; identityPath = path;
+                        const host = options.host();
+                        if (host) {
+                            recovery?.remove(); recovery = null;
+                            panel = mountNativeRequests(host, next, { health, autoStart: false,
+                                onRefresh: () => { void manualRefresh(); },
+                                isCurrent: () => identity === next && identityPath === snapshotPath() });
+                        }
+                    }
+                    state.activityIdentity = next;
+                    scheduleRefresh();
+                },
+                fail() {
+                    if (!isCurrent()) return;
+                    forget(); showRecovery('Request identity could not be loaded. Refresh requests to retry.');
+                },
+            };
+        },
+        event(name: string, value: unknown) {
+            if (health !== 'healthy' || !identity || identityPath !== snapshotPath()) return;
+            const notice = name === RUNTIME_REQUEST_NOTICE_EVENT ? parseRuntimeRequestNotice(value) : null;
+            const runtime = name === 'agent_runtime' ? parseRuntimeEvent(value) : null;
+            const replayed = value !== null && typeof value === 'object'
+                && (value as Record<string, unknown>)['sseReplay'] === true;
+            if ((notice && same(notice)) || (runtime && same(runtime)
+                && (runtime.kind === 'request' || runtime.kind === 'request-settled'
+                    || (runtime.kind === 'turn-end' && !replayed)))) scheduleRefresh();
+        },
+        dispose() {
+            ++epoch; ++snapshotGeneration; forget(); recovery?.remove(); recovery = null;
+        },
+    };
+}