cli-jaw 2.17.38 → 2.17.39

package/public/dist/index.html

@@ -31,9 +31,9 @@
         href="https://fonts.googleapis.com/css2?family=Chakra+Petch:wght@400;500;600;700&family=Outfit:wght@400;500;600;700&display=swap"
         rel="stylesheet">
     <!-- Vite handles module bundling in dev (HMR) and production (build) -->
-  <script type="module" crossorigin src="/dist/assets/app-CXraFyoA.js"></script>
-  <link rel="stylesheet" crossorigin href="/dist/assets/vendor-render-kIxHrxDV.css">
-  <link rel="stylesheet" crossorigin href="/dist/assets/app-DuyLYRC6.css">
+  <script type="module" crossorigin src="/dist/assets/app-ckFtOSgc.js"></script>
+  <link rel="stylesheet" crossorigin href="/dist/assets/vendor-render-DSSkXCir.css">
+  <link rel="stylesheet" crossorigin href="/dist/assets/app-Dskscukr.css">
 </head>
 
 <body>
@@ -334,7 +334,7 @@
                         data-i18n-aria="help.permissions.aria" aria-label="권한 도움말">?</button>
                 </label>
                 <div class="perm-toggle">
-                    <span class="perm-btn active perm-auto" ><span data-icon="exec"></span> Auto</span>
+                    <span class="perm-btn" id="configuredPerm"><span data-icon="exec"></span> <span id="configuredPermText">Configured policy: Not provided</span></span>
                 </div>
             </div>
 

package/public/dist/manager/index.html

@@ -6,9 +6,9 @@
   <link rel="icon" type="image/png" href="/dist/assets/icon-192-CwXPIYF5.png">
   <title>Jaw Manager</title>
   <script src="/manager/theme-boot.js"></script>
-  <script type="module" crossorigin src="/dist/assets/manager-BspQvGAC.js"></script>
-  <link rel="stylesheet" crossorigin href="/dist/assets/vendor-render-kIxHrxDV.css">
-  <link rel="stylesheet" crossorigin href="/dist/assets/manager-Cmu0aKPb.css">
+  <script type="module" crossorigin src="/dist/assets/manager-CTX6I1Jk.js"></script>
+  <link rel="stylesheet" crossorigin href="/dist/assets/vendor-render-DSSkXCir.css">
+  <link rel="stylesheet" crossorigin href="/dist/assets/manager-Bfy42VgJ.css">
 </head>
 <body>
   <div id="manager-root"></div>

package/public/index.html

@@ -33,6 +33,8 @@
     <link rel="stylesheet" href="/css/variables.css">
     <link rel="stylesheet" href="/css/layout.css">
     <link rel="stylesheet" href="/css/chat.css">
+    <link rel="stylesheet" href="/css/native-requests.css">
+    <link rel="stylesheet" href="/css/activity.css">
     <link rel="stylesheet" href="/css/chat-search.css">
     <link rel="stylesheet" href="/css/orc-state.css">
     <link rel="stylesheet" href="/css/workflow-cockpit.css">
@@ -344,7 +346,7 @@
                         data-i18n-aria="help.permissions.aria" aria-label="권한 도움말">?</button>
                 </label>
                 <div class="perm-toggle">
-                    <span class="perm-btn active perm-auto" ><span data-icon="exec"></span> Auto</span>
+                    <span class="perm-btn" id="configuredPerm"><span data-icon="exec"></span> <span id="configuredPermText">Configured policy: Not provided</span></span>
                 </div>
             </div>
 

package/public/js/api.ts

@@ -17,10 +17,10 @@ interface ApiResponse<T = unknown> {
 
 // Auth token cache (fetched once from same-origin endpoint)
 let _authToken: string | null = null;
-export async function getAuthToken(): Promise<string> {
+export async function getAuthToken(signal?: AbortSignal): Promise<string> {
     if (_authToken) return _authToken;
     try {
-        const res = await fetch(`${API_BASE}/api/auth/token`);
+        const res = await fetch(`${API_BASE}/api/auth/token`, signal ? { signal } : undefined);
         if (res.ok) {
             const json = await res.json();
             _authToken = json.token || '';

package/public/js/bounded-api.ts

@@ -0,0 +1,49 @@
+import { API_BASE, getAuthToken } from './api.js';
+
+export class BoundedApiError extends Error {
+    constructor(readonly status: number) { super(`Request failed (${status})`); }
+}
+
+/** Explicit, cancellable JSON requests for bounded replay and decision surfaces. */
+export async function requestBoundedJson(path: string, init: RequestInit, signal: AbortSignal, maxBytes: number): Promise<unknown> {
+    const boundedSignal=AbortSignal.any([signal,AbortSignal.timeout(15_000)]);
+    boundedSignal.throwIfAborted();
+    let rejectAbort!: (reason:unknown)=>void;
+    const aborted=new Promise<never>((_resolve,reject)=>{rejectAbort=reject;});
+    const onAbort=()=>rejectAbort(boundedSignal.reason);
+    boundedSignal.addEventListener('abort',onAbort,{once:true});
+    try {
+        const token=await Promise.race([getAuthToken(boundedSignal),aborted]);
+        boundedSignal.throwIfAborted();
+        const headers=new Headers(init.headers);
+        if (token) headers.set('Authorization','Bearer '+token);
+        const response=await Promise.race([fetch(API_BASE+path,{
+            ...init,headers,signal:boundedSignal,
+        }),aborted]);
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new BoundedApiError(response.status);
+        }
+        if (!response.headers.get('content-type')?.includes('json') || !response.body) {
+            await response.body?.cancel();
+            throw new BoundedApiError(0);
+        }
+        const reader=response.body.getReader();
+        const parts:Uint8Array[]=[];let size=0;
+        try {
+            for (;;) {
+                const next=await Promise.race([reader.read(),aborted]);if(next.done)break;
+                size+=next.value.byteLength;
+                if(size>maxBytes){await reader.cancel();throw new Error('response_size_limit');}
+                parts.push(next.value);
+            }
+        } finally {
+            if (boundedSignal.aborted) void reader.cancel().catch(() => {});
+            reader.releaseLock();
+        }
+        boundedSignal.throwIfAborted();
+        const data=new Uint8Array(size);let offset=0;
+        for(const part of parts){data.set(part,offset);offset+=part.length;}
+        return JSON.parse(new TextDecoder().decode(data)) as unknown;
+    } finally {boundedSignal.removeEventListener('abort',onAbort);}
+}

package/public/js/features/activity-discovery.ts

@@ -0,0 +1,142 @@
+import type { ActivityIdentity } from '../../../src/shared/presentation.js';
+import { readActivityRuns, type ActivityRunSummary } from '../../../src/shared/activity-read.js';
+import { readActivityHttp } from './activity-http.js';
+
+interface DiscoveryActions {
+    root(): HTMLElement | null;
+    inspect(root: HTMLElement): void;
+    recycle(root: HTMLElement): void;
+    mutate(anchor: HTMLElement, action: () => void): void;
+}
+
+/** Extra records are not necessarily orphans or chronological history. */
+export function createActivityDiscovery(actions: DiscoveryActions) {
+    let identity: ActivityIdentity | null = null;
+    let loadedSession: string | null = null;
+    let loaded = new Set<string>();
+    let rows: ActivityRunSummary[] = [];
+    let page = 0, generation = 0;
+    let after = '', nextAfter: string | undefined;
+    let incomplete = false, enabled = true, open = false;
+    let controller: AbortController | null = null;
+    let root: HTMLDetailsElement | null = null;
+    const messages = new Map<string, HTMLElement>();
+
+    function clearRows(): void {
+        for (const message of messages.values()) { actions.recycle(message); message.remove(); }
+        messages.clear();
+    }
+    function ensureRoot(): HTMLDetailsElement | null {
+        const chat = actions.root(); if (!chat) return null;
+        if (root?.isConnected) return root;
+        if (root) { open = root.open; clearRows(); root.remove(); }
+        root = document.createElement('details'); root.className = 'activity-discovery'; root.id = 'activityDiscovery';
+        root.open = open;
+        const summary = document.createElement('summary'); summary.textContent = 'Recorded runs outside the loaded transcript';
+        const status = document.createElement('p'); status.className = 'activity-discovery-status'; status.setAttribute('role', 'status');
+        const list = document.createElement('div'); list.className = 'activity-discovery-runs';
+        const nav = document.createElement('nav'); nav.setAttribute('aria-label', 'Other recorded runs');
+        const button = (text: string, action: string, click: () => void) => {
+            const element = document.createElement('button'); element.type = 'button'; element.textContent = text;
+            element.dataset['discoveryAction'] = action; element.onclick = click; return element;
+        };
+        const move = (delta: number) => {
+            page = Math.max(0, Math.min(Math.max(0, Math.ceil(rows.length / 16) - 1), page + delta)); render();
+        };
+        nav.append(button('Previous page', 'previous', () => move(-1)), button('Next page', 'next', () => move(1)),
+            button('Next record window', 'window', () => { if (nextAfter) void refresh(nextAfter); }),
+            button('Refresh recorded runs', 'refresh', () => { void refresh(); }));
+        root.append(summary, status, list, nav);
+        root.ontoggle = () => {
+            if (!root) return;
+            open = root.open;
+            if (root.open) actions.inspect(root);
+            else for (const message of messages.values()) actions.recycle(message);
+        };
+        chat.append(root); return root;
+    }
+
+    function render(): void {
+        const panel = ensureRoot(); if (!panel) return;
+        actions.mutate(panel, () => {
+            panel.hidden = rows.length === 0 && !incomplete;
+            const last = Math.max(0, Math.ceil(rows.length / 16) - 1); page = Math.min(page, last);
+            const shown = rows.slice(page * 16, (page + 1) * 16);
+            const wanted = new Set(shown.map(row => row.id));
+            for (const [id, message] of messages) if (!wanted.has(id) || !message.isConnected) {
+                actions.recycle(message); message.remove(); messages.delete(id);
+            }
+            const list = panel.querySelector<HTMLElement>('.activity-discovery-runs')!;
+            for (const row of shown) {
+                if (messages.has(row.id)) continue;
+                // Not a .msg row: legacy first-user VS bootstrap scans that class.
+                const message = document.createElement('div'); message.className = 'activity-recorded-run';
+                message.dataset['traceRunId'] = row.id; message.dataset['activityDiscovered'] = 'true';
+                message.dataset['messageSessionId'] = identity!.sessionId;
+                message.dataset['messageId'] = `recorded:${identity!.sessionId}:${row.id}`;
+                const body = document.createElement('div'); body.className = 'agent-body';
+                const label = document.createElement('p'); label.className = 'activity-record-label';
+                label.textContent = `Recorded run ${row.id}`;
+                const answer = document.createElement('div'); answer.className = 'msg-content';
+                body.append(label, answer); message.append(body); list.append(message); messages.set(row.id, message);
+            }
+            const status = panel.querySelector<HTMLElement>('.activity-discovery-status')!;
+            status.textContent = `${rows.length} other runs in this record window. Page ${rows.length ? page + 1 : 0} / ${rows.length ? last + 1 : 0}.`
+                + (incomplete ? ' Discovery is limited; more records may exist. IDs are not chronological.' : ' IDs are not chronological.');
+            panel.querySelector<HTMLButtonElement>('[data-discovery-action="previous"]')!.disabled = page === 0;
+            panel.querySelector<HTMLButtonElement>('[data-discovery-action="next"]')!.disabled = page >= last;
+            panel.querySelector<HTMLButtonElement>('[data-discovery-action="window"]')!.disabled = !nextAfter;
+        });
+        if (panel.open && enabled) actions.inspect(panel);
+    }
+
+    async function refresh(cursor = ''): Promise<void> {
+        if (!identity || !enabled || loadedSession !== identity.sessionId) return;
+        controller?.abort(); const own = new AbortController(); controller = own;
+        const captured = { ...identity }, epoch = ++generation;
+        const timer = setTimeout(() => own.abort(new DOMException('Recorded-run read deadline', 'TimeoutError')), 30_000);
+        const panel = ensureRoot();
+        if (panel) panel.querySelector<HTMLElement>('.activity-discovery-status')!.textContent = 'Loading recorded runs.';
+        try {
+            const result = await readActivityRuns({ sessionId: captured.sessionId, after: cursor,
+                signal: own.signal, read: readActivityHttp });
+            if (own.signal.aborted || generation !== epoch || loadedSession !== captured.sessionId) return;
+            after = cursor; nextAfter = result.nextAfter; incomplete = result.incomplete;
+            rows = result.runs.filter(row => !loaded.has(row.id)); page = 0; render();
+        } catch (error) {
+            if (generation !== epoch) return;
+            const current = ensureRoot();
+            if (current) {
+                current.hidden = false;
+                current.querySelector<HTMLElement>('.activity-discovery-status')!.textContent =
+                    'Recorded runs could not be loaded. The transcript is unchanged; use Refresh recorded runs to retry.';
+            }
+            if (!own.signal.aborted) console.warn('[activity] recorded-run discovery failed', error);
+        } finally { clearTimeout(timer); if (controller === own) controller = null; }
+    }
+
+    return {
+        refresh,
+        owns(message: HTMLElement) { return messages.get(message.dataset['traceRunId'] ?? '') === message; },
+        setIdentity(next: ActivityIdentity | null) {
+            if (identity?.sessionId === next?.sessionId && identity?.scope === next?.scope) return;
+            ++generation; controller?.abort(); controller = null;
+            clearRows(); root?.remove(); root = null; rows = []; page = 0; after = ''; nextAfter = undefined; incomplete = false; open = false;
+            identity = next ? { ...next } : null;
+        },
+        setTranscript(sessionId: string | null, runIds: ReadonlySet<string>) {
+            loadedSession = sessionId; loaded = new Set(runIds);
+            rows = rows.filter(row => !loaded.has(row.id)); if (root && identity) render();
+        },
+        setEnabled(value: boolean) {
+            enabled = value;
+            if (!value) { ++generation; controller?.abort(); controller = null; }
+            else if (root?.open) actions.inspect(root);
+        },
+        retry() { return refresh(after); },
+        dispose() {
+            ++generation; controller?.abort(); controller = null;
+            clearRows(); root?.remove(); root = null; rows = []; loaded.clear(); identity = null;
+        },
+    };
+}

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

@@ -0,0 +1,334 @@
+import type { ActivityIdentity } from '../../../src/shared/presentation.js';
+import type { RuntimeEvent } from '../../../src/shared/runtime-contract.js';
+import { MAX_SAVED_ACTIVITY_ANSWER_BYTES, readActivityRun, readSavedActivityAnswer,
+    type ActivityRunReadResult, type SavedActivityAnswer } from '../../../src/shared/activity-read.js';
+import { readActivityHttp, ActivityReadError } from './activity-http.js';
+import { findLiveActivity, mountHistoryActivity, recycleActivityHost, remountLiveActivity,
+    restoreLiveActivity, setActivityReadHealth, settleLiveActivity, closeActivityTrace,
+    isCurrentActivityMessage, reconcileSavedActivityAnswer } from './activity-live.js';
+import { getMessageScope } from './idb-cache.js';
+import { createActivityDiscovery } from './activity-discovery.js';
+
+export type RecoveredAnswer = { kind: 'saved'; message: SavedActivityAnswer } | { kind: 'absent' } | { kind: 'unavailable' };
+export interface RecoveredActivityTerminal {
+    runId: string; sessionId: string; scope: string; turnId?: string;
+    status: 'done' | 'error' | 'stopped'; message: HTMLElement; cacheScope: string; answer: RecoveredAnswer;
+}
+interface Callbacks {
+    terminal(value: RecoveredActivityTerminal): void;
+    refreshIdentity(): Promise<void>;
+}
+type Host = {
+    message: HTMLElement; runId: string; cacheScope: string; controller: AbortController;
+    box: HTMLElement; status: HTMLElement; retry: HTMLButtonElement;
+    pending: boolean; loaded: boolean; promise: Promise<void> | null; resolve: (() => void) | null;
+};
+const SELECTOR = '.msg-agent[data-trace-run-id], .activity-recorded-run[data-trace-run-id]';
+const MAX_HOSTS = 64, MAX_QUEUED = 16, READ_DEADLINE_MS = 30_000;
+let identity: ActivityIdentity | null = null;
+let callbacks: Callbacks | null = null;
+let loadedSession: string | null = null;
+let loadedRuns = new Set<string>();
+let generation = 0, loadingTranscript = false, automaticReads = false;
+let identityRefreshKey = '';
+let observer: IntersectionObserver | null = null, modeObserver: MutationObserver | null = null;
+let active: Host | null = null;
+const hosts = new Map<HTMLElement, Host>(), queued = new Map<HTMLElement, Host>();
+const mode = () => document.documentElement.dataset['presentationMode'] !== 'legacy';
+const chat = () => document.getElementById('chatMessages');
+const locationKey = () => `${window.location.pathname}${window.location.search}`;
+
+function mutate(anchor: HTMLElement, action: () => void): void {
+    if (window.__jawProcessBlockLayoutMutation) window.__jawProcessBlockLayoutMutation(anchor, action);
+    else action();
+}
+const discovery = createActivityDiscovery({ root: chat, inspect: root => observeActivityHistory(root),
+    recycle: root => recycleActivityHistory(root), mutate });
+
+function messageRoot(message: HTMLElement): boolean {
+    const root = chat(), parent = message.parentElement;
+    return discovery.owns(message) || !!root && (parent === root
+        || parent?.classList.contains('vs-inner') === true && parent.parentElement === root);
+}
+function owns(message: HTMLElement, runId: string, sessionId: string): boolean {
+    return messageRoot(message) && message.dataset['traceRunId'] === runId
+        && message.dataset['messageSessionId'] === sessionId
+        && (discovery.owns(message) || loadedSession === sessionId && loadedRuns.has(runId)
+            || findLiveActivity(runId)?.message === message || message.dataset['activitySession'] === sessionId
+            || message.hasAttribute('data-active-run-hydrated'));
+}
+function current(host: Host, captured: ActivityIdentity, epoch: number, path: string): boolean {
+    return hosts.get(host.message) === host && !host.controller.signal.aborted && host.message.isConnected
+        && generation === epoch && path === locationKey() && identity?.sessionId === captured.sessionId
+        && identity.scope === captured.scope && owns(host.message, host.runId, captured.sessionId);
+}
+function traceAllowed(message: HTMLElement, allowed: boolean): void {
+    message.querySelectorAll<HTMLElement>('.process-step-trace').forEach(button => {
+        button.setAttribute('aria-disabled', String(!allowed));
+        button.tabIndex = allowed ? 0 : -1;
+        if (button instanceof window.HTMLButtonElement) button.disabled = !allowed;
+    });
+}
+function finishPromise(host: Host): void {
+    host.retry.disabled = false;
+    host.pending = false; host.resolve?.(); host.resolve = null; host.promise = null;
+}
+function cancel(host: Host, remove: boolean): void {
+    host.controller.abort();
+    if (remove) observer?.unobserve(host.message);
+    else {
+        host.status.textContent = 'Activity read cancelled. Retry to inspect.';
+        host.retry.textContent = 'Retry activity'; host.retry.hidden = false; host.box.hidden = false;
+    }
+    if (queued.delete(host.message)) finishPromise(host);
+    if (remove) { hosts.delete(host.message); host.box.remove(); }
+}
+function prune(): void {
+    for (const host of hosts.values()) if (!host.message.isConnected) cancel(host, true);
+    if (hosts.size < MAX_HOSTS) document.getElementById('activityHistoryCapacity')?.remove();
+}
+
+function entry(message: HTMLElement, runId: string): Host | null {
+    const previous = hosts.get(message);
+    if (previous?.runId === runId) return previous;
+    if (previous) cancel(previous, true);
+    prune();
+    if (hosts.size >= MAX_HOSTS) {
+        if (!document.getElementById('activityHistoryCapacity')) {
+            const notice = document.createElement('p'); notice.id = 'activityHistoryCapacity';
+            notice.className = 'activity-read-capacity'; notice.setAttribute('role', 'status');
+            notice.textContent = 'Activity inspection is at its display limit. Existing answers remain available; scroll unused records away before retrying.';
+            chat()?.append(notice);
+        }
+        return null;
+    }
+    message.querySelector('.activity-read-control')?.remove();
+    const box = document.createElement('div'); box.className = 'activity-read-control';
+    const status = document.createElement('p'); status.setAttribute('role', 'status');
+    const retry = document.createElement('button'); retry.type = 'button'; retry.textContent = 'Load activity';
+    box.append(status, retry); message.querySelector('.agent-body')?.prepend(box);
+    const host: Host = { message, runId, cacheScope: getMessageScope(), controller: new AbortController(),
+        box, status, retry, pending: false, loaded: false, promise: null, resolve: null };
+    retry.onclick = () => { void hydrateActivityHost(message, runId, true); };
+    hosts.set(message, host); if (mode()) traceAllowed(message, false);
+    return host;
+}
+
+/** Called by live eviction; deliberately does not schedule another read reentrantly. */
+export function markActivityHistoryUnavailable(message: HTMLElement): void {
+    if (!identity || !owns(message, message.dataset['traceRunId'] ?? '', identity.sessionId)) return;
+    const host = entry(message, message.dataset['traceRunId']!); if (!host) return;
+    host.loaded = false; host.box.hidden = false; host.retry.hidden = false;
+    host.status.textContent = 'Activity preview is no longer retained in memory. Load it again to inspect.';
+}
+
+function combine(seed: ActivityRunReadResult, tail: ActivityRunReadResult): RuntimeEvent[] {
+    if (seed.scope !== tail.scope) throw new Error('activity_scope_changed');
+    const result = [...seed.events, ...tail.events];
+    if (result.length > 4096) throw new Error('activity_run_limit');
+    let bytes = 0; const encoder = new TextEncoder(); const turnId = result[0]?.turnId;
+    for (const event of result) {
+        if (event.turnId !== turnId) throw new Error('activity_turn_changed');
+        bytes += encoder.encode(JSON.stringify(event)).length;
+        if (bytes > 4 * 1024 * 1024) throw new Error('activity_run_limit');
+    }
+    return result;
+}
+
+async function execute(host: Host): Promise<void> {
+    const captured = identity; if (!captured) return;
+    const epoch = generation, path = locationKey();
+    const timer = setTimeout(() => host.controller.abort(new DOMException('Activity read deadline', 'TimeoutError')), READ_DEADLINE_MS);
+    const hadFocus = host.retry === document.activeElement;
+    if (isCurrentActivityMessage(host.message) && host.message.dataset['activitySaved'] !== 'true')
+        host.message.dataset['activityRecovering'] = 'true';
+    let seed: ActivityRunReadResult | undefined, tail: ActivityRunReadResult | undefined;
+    try {
+        await restoreLiveActivity(async signal => {
+            seed = await readActivityRun({ runId: host.runId, sessionId: captured.sessionId, signal, read: readActivityHttp });
+            if (!current(host, captured, epoch, path)) throw new DOMException('History context changed', 'AbortError');
+            tail = await readActivityRun({ runId: host.runId, sessionId: captured.sessionId,
+                after: seed.through, signal, read: readActivityHttp });
+            if (!current(host, captured, epoch, path)) throw new DOMException('History context changed', 'AbortError');
+            return combine(seed, tail);
+        }, { runId: host.runId, signal: host.controller.signal });
+        if (!current(host, captured, epoch, path) || !seed || !tail) return;
+        // Validated history ownership survives removal of the transient active
+        // snapshot marker, including an empty journal's first successful answer.
+        host.message.dataset['activitySession'] = captured.sessionId;
+        const result = tail;
+        let turn = findLiveActivity(host.runId);
+        const recordedEnd = [...seed.events, ...result.events].find(event => event.kind === 'turn-end');
+        const status = turn?.model.end?.status ?? (recordedEnd?.kind === 'turn-end' ? recordedEnd.status
+            : result.status === 'interrupted' ? 'stopped' : result.status);
+        const incomplete = seed.incomplete || result.incomplete;
+        traceAllowed(host.message, true);
+        let answer: RecoveredAnswer = { kind: 'unavailable' };
+        let answerError: unknown;
+        if (status !== 'running') {
+            try {
+                const saved = await readSavedActivityAnswer({ runId: host.runId, sessionId: captured.sessionId,
+                    signal: host.controller.signal,
+                    read: (request, signal) => readActivityHttp(request, signal, MAX_SAVED_ACTIVITY_ANSWER_BYTES) });
+                answer = saved ? { kind: 'saved', message: saved } : { kind: 'absent' };
+            } catch (error) { answerError = error; }
+            if (!current(host, captured, epoch, path)) return;
+        }
+        // A duplicate saved association must not move one run's view between rows.
+        if (!(answerError instanceof ActivityReadError && answerError.status === 409))
+            turn = mountHistoryActivity(host.message, host.runId) ?? turn;
+        if (status !== 'running') settleLiveActivity(host.runId, status);
+        setActivityReadHealth(host.runId, incomplete);
+        if (status !== 'running') {
+            callbacks?.terminal({ runId: host.runId, sessionId: captured.sessionId, scope: result.scope,
+                ...(turn ? { turnId: turn.model.identity.turnId } : {}), status,
+                message: host.message, cacheScope: host.cacheScope, answer });
+            turn = findLiveActivity(host.runId);
+            if (answer.kind === 'saved') {
+                const message = turn?.message ?? host.message;
+                if (!reconcileSavedActivityAnswer(message, answer.message, host.cacheScope))
+                    answerError = new Error('saved_message_identity_changed');
+            }
+        }
+        if (!current(host, captured, epoch, path)) return;
+        host.loaded = true;
+        const noActivity = !turn;
+        host.status.textContent = answerError instanceof ActivityReadError ? answerError.message
+            : answerError ? 'The saved answer could not be recovered. Retry; existing text is unchanged.'
+            : incomplete ? 'Some recorded activity is unavailable. Existing saved or live answers are unchanged.'
+            : noActivity ? 'No detailed Activity is retained. The saved transcript and authorized Trace remain available.'
+            : status !== 'running' && answer.kind === 'absent' ? 'No saved answer is linked to this run. Inspect retained Activity in Trace.'
+            : '';
+        host.retry.textContent = 'Refresh activity';
+        host.retry.hidden = !incomplete && !noActivity && !answerError && status !== 'running' && answer.kind === 'saved';
+        host.box.hidden = host.retry.hidden;
+        if (hadFocus && host.box.hidden) host.message.querySelector<HTMLElement>('.activity-summary')?.focus({ preventScroll: true });
+    } catch (error) {
+        if (hosts.get(host.message) !== host || generation !== epoch || path !== locationKey()) return;
+        if (host.controller.signal.aborted && host.controller.signal.reason?.name !== 'TimeoutError') return;
+        host.status.textContent = error instanceof ActivityReadError ? error.message
+            : 'Activity could not be restored. The transcript is unchanged; retry to inspect it.';
+        host.retry.hidden = false; host.box.hidden = false; host.retry.textContent = 'Retry activity';
+        if (error instanceof ActivityReadError && error.status === 404) {
+            try {
+                await readActivityHttp(`/api/traces/${encodeURIComponent(host.runId)}?${new URLSearchParams({ session: captured.sessionId })}`,
+                    host.controller.signal);
+                if (current(host, captured, epoch, path)) {
+                    traceAllowed(host.message, true);
+                    host.status.textContent = 'Detailed Activity was not recorded for this turn. The saved transcript is shown.';
+                    host.retry.hidden = true;
+                }
+            } catch { /* A copied/foreign/expired pointer does not gain raw authority. */ }
+        }
+    } finally {
+        clearTimeout(timer);
+        if (hosts.get(host.message) === host) {
+            if (!host.controller.signal.aborted || host.controller.signal.reason?.name === 'TimeoutError') host.loaded = true;
+        }
+    }
+}
+
+function pump(): void {
+    if (active) return;
+    const next = queued.entries().next().value as [HTMLElement, Host] | undefined;
+    if (!next) return;
+    queued.delete(next[0]); const host = next[1];
+    if (!host.message.isConnected || host.controller.signal.aborted || hosts.get(host.message) !== host) {
+        finishPromise(host); queueMicrotask(pump); return;
+    }
+    active = host; host.status.textContent = 'Loading recorded activity.';
+    void execute(host).catch(error => console.warn('[activity] history read failed', error)).finally(() => {
+        finishPromise(host); if (active === host) active = null; pump();
+    });
+}
+
+export function hydrateActivityHost(message: HTMLElement, runId: string, manual = false): Promise<void> {
+    if (!identity || !owns(message, runId, identity.sessionId) || !message.isConnected || loadingTranscript) return Promise.resolve();
+    if (!manual && (!mode() || !automaticReads)) return Promise.resolve();
+    const host = entry(message, runId); if (!host) return Promise.resolve();
+    if (host.pending) return host.promise!;
+    const turn = findLiveActivity(runId);
+    if (!manual && host.loaded) return Promise.resolve();
+    if (!manual && turn?.message === message && !turn.degraded && !message.dataset['activityRecovering']) {
+        host.box.hidden = true; traceAllowed(message, true); return Promise.resolve();
+    }
+    if (queued.size >= MAX_QUEUED) {
+        host.status.textContent = 'Activity reads are at their limit. Use Load activity to retry.';
+        host.box.hidden = false; host.retry.hidden = false; return Promise.resolve();
+    }
+    host.controller = new AbortController(); host.pending = true; host.box.hidden = false;
+    host.status.textContent = 'Activity read queued.'; host.retry.disabled = true;
+    host.promise = new Promise(resolve => { host.resolve = resolve; });
+    const promise = host.promise; queued.set(message, host); pump(); return promise;
+}
+
+export function recycleActivityHistory(root: ParentNode): void {
+    for (const message of root.querySelectorAll<HTMLElement>('[data-activity-key]')) recycleActivityHost(message);
+    if (root instanceof HTMLElement && root.dataset['activityKey']) recycleActivityHost(root);
+    for (const [message, host] of hosts) if (root === message || root.contains(message)) {
+        cancel(host, true); recycleActivityHost(message);
+    }
+}
+
+export function observeActivityHistory(root: ParentNode): void {
+    if (!identity || loadingTranscript) return;
+    prune(); remountLiveActivity(root);
+    if (!observer && typeof IntersectionObserver !== 'undefined') observer = new IntersectionObserver(entries => {
+        for (const item of entries) {
+            const message = item.target as HTMLElement, host = hosts.get(message);
+            if (item.isIntersecting) void hydrateActivityHost(message, message.dataset['traceRunId'] ?? '');
+            else if (host?.pending && !message.contains(document.activeElement)) cancel(host, false);
+        }
+    }, { root: chat() });
+    for (const message of root.querySelectorAll<HTMLElement>(SELECTOR)) {
+        const runId = message.dataset['traceRunId']!;
+        if (!owns(message, runId, identity.sessionId)) continue;
+        const host = entry(message, runId); if (!host) continue;
+        if (!mode()) { host.box.hidden = true; traceAllowed(message, true); continue; }
+        if (message.closest('details:not([open])')) continue;
+        if (observer) observer.observe(message); else void hydrateActivityHost(message, runId);
+    }
+}
+
+export function prepareActivityTranscript(): void {
+    loadingTranscript = true; ++generation;
+    for (const host of hosts.values()) if (host.pending) cancel(host, false);
+    discovery.setEnabled(false);
+}
+export function setActivityTranscript(sessionId: string | null, runIds: ReadonlySet<string>): void {
+    loadingTranscript = false; loadedSession = sessionId; loadedRuns = new Set(runIds);
+    discovery.setTranscript(sessionId, runIds); discovery.setEnabled(automaticReads && mode());
+    if (identity && sessionId && identity.sessionId !== sessionId && callbacks) {
+        const key = `${locationKey()}:${sessionId}`;
+        if (identityRefreshKey !== key) { identityRefreshKey = key; void callbacks.refreshIdentity().catch(() => {}); }
+    }
+    const root = chat(); if (root) observeActivityHistory(root);
+}
+export function setActivityHistoryIdentity(next: ActivityIdentity | null, handlers: Callbacks): void {
+    callbacks = handlers;
+    if (identity?.sessionId !== next?.sessionId || identity?.scope !== next?.scope) {
+        ++generation; for (const host of hosts.values()) cancel(host, true);
+        observer?.disconnect(); observer = null; closeActivityTrace(); identityRefreshKey = '';
+    }
+    identity = next ? { ...next } : null; discovery.setIdentity(identity);
+    if (!modeObserver) {
+        modeObserver = new MutationObserver(() => {
+            discovery.setEnabled(automaticReads && mode());
+            if (!mode()) for (const host of hosts.values()) if (host.pending) cancel(host, false);
+            const root = chat(); if (root) observeActivityHistory(root);
+        });
+        modeObserver.observe(document.documentElement, { attributes: true, attributeFilter: ['data-presentation-mode'] });
+    }
+}
+export function setActivityHistoryReadReady(ready: boolean): void {
+    automaticReads = ready; discovery.setEnabled(ready && mode());
+    if (!ready) {
+        for (const host of hosts.values()) if (host.pending) cancel(host, false);
+    } else { const root = chat(); if (root) observeActivityHistory(root); }
+}
+export function discoverActivityHistory(): Promise<void> { return discovery.refresh(); }
+export function disposeActivityHistory(): void {
+    ++generation; for (const host of hosts.values()) cancel(host, true);
+    observer?.disconnect(); observer = null; modeObserver?.disconnect(); modeObserver = null;
+    discovery.dispose(); identity = null; loadedSession = null; loadedRuns.clear(); callbacks = null;
+}

package/public/js/features/activity-http.ts

@@ -0,0 +1,17 @@
+import { BoundedApiError, requestBoundedJson } from '../bounded-api.js';
+
+export class ActivityReadError extends Error {
+    constructor(readonly status: number) {
+        super(status === 401 || status === 403 ? 'Activity access is unavailable. Check this instance connection.'
+            : status === 404 ? 'Activity is unavailable for this conversation.'
+            : status === 409 ? 'More than one saved answer refers to this run. The existing transcript is unchanged.'
+            : status === 413 ? 'The saved answer exceeds the inline recovery limit. The existing transcript is unchanged.'
+            : 'Activity could not be loaded. Retry when the connection is available.');
+    }
+}
+
+/** Unlike the general API helper, replay must preserve aborts and failed reads. */
+export async function readActivityHttp(path: string, signal: AbortSignal, maxBytes = 270_000): Promise<unknown> {
+    try { return await requestBoundedJson(path,{},signal,maxBytes); }
+    catch(error) { if(error instanceof BoundedApiError) throw new ActivityReadError(error.status); throw error; }
+}