ahp-inspector 1.2.0 → 1.3.1

package/dist/index.js

@@ -2351,12 +2351,19 @@ var TailReader = class {
       this.#lastOffset = 0;
       return;
     }
+    sink.onInitialReadStart?.({ totalBytes: sizeAtStart });
     if (sizeAtStart === 0) {
       this.#lastOffset = 0;
+      sink.onInitialReadComplete?.({ loadedBytes: 0, totalBytes: 0 });
       return;
     }
-    await this.#readRange(0, sizeAtStart, sink);
-    this.#lastOffset = sizeAtStart;
+    const result = await this.#readRange(0, sizeAtStart, sink, (loadedBytes) => {
+      sink.onInitialReadProgress?.({ loadedBytes, totalBytes: sizeAtStart });
+    });
+    this.#lastOffset = result.nextOffset;
+    if (result.completed && result.nextOffset >= sizeAtStart) {
+      sink.onInitialReadComplete?.({ loadedBytes: sizeAtStart, totalBytes: sizeAtStart });
+    }
   }
   /**
    * Subscribe to file growth, rotation, and errors. Returns a disposer that
@@ -2410,8 +2417,8 @@ var TailReader = class {
       }
       if (nextSize === this.#lastOffset) return;
       const start = this.#lastOffset;
-      await this.#readRange(start, nextSize, sink);
-      this.#lastOffset = nextSize;
+      const result = await this.#readRange(start, nextSize, sink);
+      this.#lastOffset = result.nextOffset;
     } finally {
       this.#readInFlight = false;
       if (this.#readAgainAfterCurrent && !this.#disposed) {
@@ -2433,11 +2440,11 @@ var TailReader = class {
     this.#lastOffset = 0;
     sink.onReset({ newSize, reason });
     if (newSize > 0) {
-      await this.#readRange(0, newSize, sink);
-      this.#lastOffset = newSize;
+      const result = await this.#readRange(0, newSize, sink);
+      this.#lastOffset = result.nextOffset;
     }
   }
-  #readRange(start, end, sink) {
+  #readRange(start, end, sink, onProgress) {
     return new Promise((resolve3) => {
       const stream2 = createReadStream(this.#path, {
         start,
@@ -2453,11 +2460,12 @@ var TailReader = class {
         })();
         sink.onChunk(bytes, cursor);
         cursor += bytes.byteLength;
+        onProgress?.(cursor);
       });
-      stream2.on("end", () => resolve3());
+      stream2.on("end", () => resolve3({ completed: true, nextOffset: cursor }));
       stream2.on("error", (err) => {
         sink.onError(err, false);
-        resolve3();
+        resolve3({ completed: false, nextOffset: cursor });
       });
     });
   }
@@ -2529,6 +2537,7 @@ var Correlator = class {
   #store;
   #pendingRequests = /* @__PURE__ */ new Map();
   #pendingResponses = /* @__PURE__ */ new Map();
+  #changedIndexes = /* @__PURE__ */ new Set();
   #unsubscribe;
   pairIdx = [];
   latencyMs = [];
@@ -2548,6 +2557,11 @@ var Correlator = class {
   statusOf(idx) {
     return this.status[idx] ?? "n/a";
   }
+  drainChangedIndexes() {
+    const indexes = [...this.#changedIndexes];
+    this.#changedIndexes.clear();
+    return indexes;
+  }
   /**
    * Advance time. Any request still pending older than `timeoutMs` becomes
    * 'unmatched'. Cheap O(pendingRequests).
@@ -2557,6 +2571,7 @@ var Correlator = class {
       const ts = this.#store.ts[idx];
       if (ts !== void 0 && nowMs - ts >= timeoutMs) {
         this.status[idx] = "unmatched";
+        this.#changedIndexes.add(idx);
         this.#pendingRequests.delete(key);
       }
     }
@@ -2569,6 +2584,7 @@ var Correlator = class {
   reset() {
     this.#pendingRequests.clear();
     this.#pendingResponses.clear();
+    this.#changedIndexes.clear();
     this.pairIdx.length = 0;
     this.latencyMs.length = 0;
     this.status.length = 0;
@@ -2600,9 +2616,11 @@ var Correlator = class {
     const displaced = this.#pendingRequests.get(key);
     if (displaced !== void 0) {
       this.status[displaced] = "orphan";
+      this.#changedIndexes.add(displaced);
     }
     this.#pendingRequests.set(key, idx);
     this.status[idx] = "pending";
+    this.#changedIndexes.add(idx);
   }
   #onResponse(idx, ev) {
     const key = correlationKeyForResponse(ev);
@@ -2615,6 +2633,7 @@ var Correlator = class {
     const displaced = this.#pendingResponses.get(key);
     if (displaced !== void 0) {
       this.status[displaced] = "orphan";
+      this.#changedIndexes.add(displaced);
     }
     this.#pendingResponses.set(key, idx);
   }
@@ -2629,6 +2648,8 @@ var Correlator = class {
     const s = isError ? "error" : "ok";
     this.status[reqIdx] = s;
     this.status[respIdx] = s;
+    this.#changedIndexes.add(reqIdx);
+    this.#changedIndexes.add(respIdx);
   }
 };
 function isErrorResponse(ev) {
@@ -2739,7 +2760,7 @@ var IS_CLIENT_DISPATCHABLE = {
   ["root/configChanged" /* RootConfigChanged */]: true,
   ["session/ready" /* SessionReady */]: false,
   ["session/creationFailed" /* SessionCreationFailed */]: false,
-  ["session/turnStarted" /* SessionTurnStarted */]: true,
+  ["session/turnStarted" /* SessionTurnStarted */]: false,
   ["session/delta" /* SessionDelta */]: false,
   ["session/responsePart" /* SessionResponsePart */]: false,
   ["session/toolCallStart" /* SessionToolCallStart */]: false,
@@ -2767,13 +2788,19 @@ var IS_CLIENT_DISPATCHABLE = {
   ["session/inputCompleted" /* SessionInputCompleted */]: true,
   ["session/customizationsChanged" /* SessionCustomizationsChanged */]: false,
   ["session/customizationToggled" /* SessionCustomizationToggled */]: true,
+  ["session/customizationUpdated" /* SessionCustomizationUpdated */]: false,
   ["session/truncated" /* SessionTruncated */]: true,
   ["session/isReadChanged" /* SessionIsReadChanged */]: true,
   ["session/isArchivedChanged" /* SessionIsArchivedChanged */]: true,
   ["session/activityChanged" /* SessionActivityChanged */]: false,
-  ["session/diffsChanged" /* SessionDiffsChanged */]: false,
+  ["session/changesetsChanged" /* SessionChangesetsChanged */]: false,
   ["session/configChanged" /* SessionConfigChanged */]: true,
   ["session/metaChanged" /* SessionMetaChanged */]: false,
+  ["changeset/statusChanged" /* ChangesetStatusChanged */]: false,
+  ["changeset/fileSet" /* ChangesetFileSet */]: false,
+  ["changeset/fileRemoved" /* ChangesetFileRemoved */]: false,
+  ["changeset/operationsChanged" /* ChangesetOperationsChanged */]: false,
+  ["changeset/cleared" /* ChangesetCleared */]: false,
   ["terminal/data" /* TerminalData */]: false,
   ["terminal/input" /* TerminalInput */]: true,
   ["terminal/resized" /* TerminalResized */]: true,
@@ -2787,11 +2814,39 @@ var IS_CLIENT_DISPATCHABLE = {
   ["terminal/commandFinished" /* TerminalCommandFinished */]: false
 };
 
-// ../protocol/src/reducers.ts
+// ../protocol/src/common/reducer-helpers.ts
 function softAssertNever(value, log) {
   const msg = `Unhandled action type: ${JSON.stringify(value)}`;
   (log ?? console.warn)(msg);
 }
+
+// ../protocol/src/channels-root/reducer.ts
+function rootReducer(state, action, log) {
+  switch (action.type) {
+    case "root/agentsChanged" /* RootAgentsChanged */:
+      return { ...state, agents: action.agents };
+    case "root/activeSessionsChanged" /* RootActiveSessionsChanged */:
+      return { ...state, activeSessions: action.activeSessions };
+    case "root/terminalsChanged" /* RootTerminalsChanged */:
+      return { ...state, terminals: action.terminals };
+    case "root/configChanged" /* RootConfigChanged */:
+      if (!state.config) {
+        return state;
+      }
+      return {
+        ...state,
+        config: {
+          ...state.config,
+          values: action.replace ? { ...action.config } : { ...state.config.values, ...action.config }
+        }
+      };
+    default:
+      softAssertNever(action, log);
+      return state;
+  }
+}
+
+// ../protocol/src/channels-session/reducer.ts
 function tcBase(tc) {
   return {
     toolCallId: tc.toolCallId,
@@ -2952,30 +3007,6 @@ function updateResponsePart(state, turnId, partId, updater) {
     activeTurn: { ...activeTurn, responseParts }
   };
 }
-function rootReducer(state, action, log) {
-  switch (action.type) {
-    case "root/agentsChanged" /* RootAgentsChanged */:
-      return { ...state, agents: action.agents };
-    case "root/activeSessionsChanged" /* RootActiveSessionsChanged */:
-      return { ...state, activeSessions: action.activeSessions };
-    case "root/terminalsChanged" /* RootTerminalsChanged */:
-      return { ...state, terminals: action.terminals };
-    case "root/configChanged" /* RootConfigChanged */:
-      if (!state.config) {
-        return state;
-      }
-      return {
-        ...state,
-        config: {
-          ...state.config,
-          values: action.replace ? { ...action.config } : { ...state.config.values, ...action.config }
-        }
-      };
-    default:
-      softAssertNever(action, log);
-      return state;
-  }
-}
 function sessionReducer(state, action, log) {
   switch (action.type) {
     // ── Lifecycle ──────────────────────────────────────────────────────────
@@ -3259,26 +3290,46 @@ function sessionReducer(state, action, log) {
         ...state,
         summary: { ...state.summary, activity: action.activity }
       };
-    case "session/diffsChanged" /* SessionDiffsChanged */:
-      return {
-        ...state,
-        summary: { ...state.summary, diffs: action.diffs }
-      };
-    case "session/configChanged" /* SessionConfigChanged */:
+    case "session/changesetsChanged" /* SessionChangesetsChanged */: {
+      const { changesets: _omit, ...summaryWithoutChangesets } = state.summary;
+      const newSummary = action.changesets ? { ...summaryWithoutChangesets, changesets: action.changesets } : summaryWithoutChangesets;
+      return { ...state, summary: newSummary };
+    }
+    case "session/configChanged" /* SessionConfigChanged */: {
       if (!state.config) {
+        if (!action.schema) {
+          return state;
+        }
+        return {
+          ...state,
+          config: {
+            schema: action.schema,
+            values: action.config ? { ...action.config } : {}
+          },
+          summary: {
+            ...state.summary,
+            modifiedAt: Date.now()
+          }
+        };
+      }
+      const values = action.config !== void 0 ? action.replace ? { ...action.config } : { ...state.config.values, ...action.config } : state.config.values;
+      const schema = action.schema ?? state.config.schema;
+      if (values === state.config.values && schema === state.config.schema) {
         return state;
       }
       return {
         ...state,
         config: {
           ...state.config,
-          values: action.replace ? { ...action.config } : { ...state.config.values, ...action.config }
+          schema,
+          values
         },
         summary: {
           ...state.summary,
           modifiedAt: Date.now()
         }
       };
+    }
     case "session/metaChanged" /* SessionMetaChanged */:
       return { ...state, _meta: action._meta };
     case "session/serverToolsChanged" /* SessionServerToolsChanged */:
@@ -3312,6 +3363,36 @@ function sessionReducer(state, action, log) {
       updated[idx] = { ...list[idx], enabled: action.enabled };
       return { ...state, customizations: updated };
     }
+    case "session/customizationUpdated" /* SessionCustomizationUpdated */: {
+      const list = state.customizations ?? [];
+      const idx = list.findIndex((c) => c.customization.uri === action.customization.uri);
+      if (idx < 0) {
+        const inserted = {
+          customization: action.customization,
+          enabled: action.enabled ?? false
+        };
+        if (action.status !== void 0) {
+          inserted.status = action.status;
+        }
+        if (action.statusMessage !== void 0) {
+          inserted.statusMessage = action.statusMessage;
+        }
+        return { ...state, customizations: [...list, inserted] };
+      }
+      const updated = [...list];
+      const next = { ...list[idx], customization: action.customization };
+      if (action.enabled !== void 0) {
+        next.enabled = action.enabled;
+      }
+      if (action.status !== void 0) {
+        next.status = action.status;
+      }
+      if (action.statusMessage !== void 0) {
+        next.statusMessage = action.statusMessage;
+      }
+      updated[idx] = next;
+      return { ...state, customizations: updated };
+    }
     // ── Truncation ────────────────────────────────────────────────────────
     case "session/truncated" /* SessionTruncated */: {
       let turns;
@@ -3437,6 +3518,8 @@ function sessionReducer(state, action, log) {
       return state;
   }
 }
+
+// ../protocol/src/channels-terminal/reducer.ts
 function terminalReducer(state, action, log) {
   switch (action.type) {
     case "terminal/data" /* TerminalData */: {
@@ -3541,13 +3624,19 @@ var ACTION_INTRODUCED_IN = {
   ["session/inputCompleted" /* SessionInputCompleted */]: "0.1.0",
   ["session/customizationsChanged" /* SessionCustomizationsChanged */]: "0.1.0",
   ["session/customizationToggled" /* SessionCustomizationToggled */]: "0.1.0",
+  ["session/customizationUpdated" /* SessionCustomizationUpdated */]: "0.1.0",
   ["session/truncated" /* SessionTruncated */]: "0.1.0",
   ["session/isReadChanged" /* SessionIsReadChanged */]: "0.1.0",
   ["session/isArchivedChanged" /* SessionIsArchivedChanged */]: "0.1.0",
   ["session/activityChanged" /* SessionActivityChanged */]: "0.1.0",
-  ["session/diffsChanged" /* SessionDiffsChanged */]: "0.1.0",
+  ["session/changesetsChanged" /* SessionChangesetsChanged */]: "0.2.0",
   ["session/configChanged" /* SessionConfigChanged */]: "0.1.0",
   ["session/metaChanged" /* SessionMetaChanged */]: "0.1.0",
+  ["changeset/statusChanged" /* ChangesetStatusChanged */]: "0.2.0",
+  ["changeset/fileSet" /* ChangesetFileSet */]: "0.2.0",
+  ["changeset/fileRemoved" /* ChangesetFileRemoved */]: "0.2.0",
+  ["changeset/operationsChanged" /* ChangesetOperationsChanged */]: "0.2.0",
+  ["changeset/cleared" /* ChangesetCleared */]: "0.2.0",
   ["root/terminalsChanged" /* RootTerminalsChanged */]: "0.1.0",
   ["root/configChanged" /* RootConfigChanged */]: "0.1.0",
   ["terminal/data" /* TerminalData */]: "0.1.0",
@@ -3562,12 +3651,6 @@ var ACTION_INTRODUCED_IN = {
   ["terminal/commandExecuted" /* TerminalCommandExecuted */]: "0.1.0",
   ["terminal/commandFinished" /* TerminalCommandFinished */]: "0.1.0"
 };
-var NOTIFICATION_INTRODUCED_IN = {
-  ["notify/sessionAdded" /* SessionAdded */]: "0.1.0",
-  ["notify/sessionRemoved" /* SessionRemoved */]: "0.1.0",
-  ["notify/sessionSummaryChanged" /* SessionSummaryChanged */]: "0.1.0",
-  ["notify/authRequired" /* AuthRequired */]: "0.1.0"
-};
 
 // ../core/src/replay.ts
 var ROOT_RESOURCE = "agenthost:/root";
@@ -3747,7 +3830,7 @@ function installSnapshot(ctx, value, eventIdx) {
   });
 }
 function applyEnvelope(ctx, envelope, eventIdx, eventTs) {
-  const target = inferActionTarget(envelope.action);
+  const target = inferActionTarget(envelope.action, envelope.channel);
   if (!target) {
     addDiagnostic(ctx, {
       code: "unknown-action",
@@ -3838,7 +3921,8 @@ function recordClientIntent(ctx, event, eventIdx) {
   const action = isRecord(params) && isRecord(params.action) ? params.action : null;
   const clientSeq = isRecord(params) && typeof params.clientSeq === "number" ? params.clientSeq : null;
   const actionType = actionTypeOf(action);
-  const resource = action ? inferActionTarget(action) : null;
+  const channel = isRecord(params) && typeof params.channel === "string" ? params.channel : void 0;
+  const resource = action ? inferActionTarget(action, channel) : null;
   const intent = {
     eventIdx,
     ts: event.ts,
@@ -3896,7 +3980,7 @@ function readSnapshot(value) {
   };
 }
 function readActionEnvelope(value) {
-  if (!isRecord(value) || typeof value.serverSeq !== "number" || !isRecord(value.action)) {
+  if (!isRecord(value) || typeof value.channel !== "string" || typeof value.serverSeq !== "number" || !isRecord(value.action)) {
     return null;
   }
   if (typeof value.action.type !== "string") {
@@ -3904,6 +3988,7 @@ function readActionEnvelope(value) {
   }
   const origin = isRecord(value.origin) && typeof value.origin.clientId === "string" && typeof value.origin.clientSeq === "number" ? { clientId: value.origin.clientId, clientSeq: value.origin.clientSeq } : void 0;
   return {
+    channel: value.channel,
     action: value.action,
     serverSeq: value.serverSeq,
     origin,
@@ -3925,20 +4010,20 @@ function inferSnapshotKind(snapshot) {
   }
   return "unknown";
 }
-function inferActionTarget(action) {
+function inferActionTarget(action, channel) {
   const type = actionTypeOf(action);
   if (!type) {
     return null;
   }
   if (type.startsWith("root/")) {
-    return { kind: "root", uri: ROOT_RESOURCE };
+    return { kind: "root", uri: channel ?? ROOT_RESOURCE };
   }
   if (type.startsWith("session/")) {
-    const session = isRecord(action) && typeof action.session === "string" ? action.session : null;
+    const session = channel ?? (isRecord(action) && typeof action.session === "string" ? action.session : null);
     return session ? { kind: "session", uri: session } : null;
   }
   if (type.startsWith("terminal/")) {
-    const terminal = isRecord(action) && typeof action.terminal === "string" ? action.terminal : null;
+    const terminal = channel ?? (isRecord(action) && typeof action.terminal === "string" ? action.terminal : null);
     return terminal ? { kind: "terminal", uri: terminal } : null;
   }
   return null;
@@ -4103,12 +4188,14 @@ function readKnownAction(value) {
 }
 function readActionEnvelope2(value) {
   if (!isRecord2(value)) return null;
+  if (typeof value.channel !== "string") return null;
   if (typeof value.serverSeq !== "number") return null;
   const action = asRecord(value.action);
   if (!action || typeof action.type !== "string") return null;
   const origin = isRecord2(value.origin) && typeof value.origin.clientId === "string" && typeof value.origin.clientSeq === "number" ? { clientId: value.origin.clientId, clientSeq: value.origin.clientSeq } : void 0;
   const known = readKnownAction(action);
   return {
+    channel: value.channel,
     action: known ?? action,
     serverSeq: value.serverSeq,
     origin,
@@ -4194,7 +4281,7 @@ function summarizeResponse(view) {
 }
 function summarizeAction(view) {
   if (isKnownAction(view.action)) {
-    return summarizeKnownAction(view.action);
+    return summarizeKnownAction(view.action, view.envelope?.channel ?? null);
   }
   return summarizeUnknownAction(view.action);
 }
@@ -4207,7 +4294,7 @@ function summarizeProtocolNotification(view) {
 function summarizeLog(view) {
   return `log ${clip(view.message ?? "details unavailable")}`;
 }
-function summarizeKnownAction(action) {
+function summarizeKnownAction(action, channel) {
   switch (action.type) {
     case "session/delta" /* SessionDelta */:
       return `delta "${clip(action.content)}"`;
@@ -4216,13 +4303,13 @@ function summarizeKnownAction(action) {
     case "session/toolCallStart" /* SessionToolCallStart */:
       return `tool start ${action.toolName}${action.displayName ? ` (${clip(action.displayName, 32)})` : ""}`;
     case "session/toolCallDelta" /* SessionToolCallDelta */:
-      return `tool delta ${action.toolCallId} +${action.content.length}b`;
+      return summarizeToolCallDelta(action);
     case "session/toolCallReady" /* SessionToolCallReady */:
       return `tool ready ${action.toolCallId} ${stringOrMd(action.invocationMessage, 48)}`;
     case "session/toolCallComplete" /* SessionToolCallComplete */:
       return `tool result ${action.toolCallId} success=${action.result.success}`;
     case "session/toolCallContentChanged" /* SessionToolCallContentChanged */:
-      return `tool content ${action.toolCallId} (${action.content.length} parts)`;
+      return summarizeToolCallContentChanged(action);
     case "session/turnStarted" /* SessionTurnStarted */:
       return `turn start ${shortId(action.turnId)}`;
     case "session/turnComplete" /* SessionTurnComplete */:
@@ -4240,15 +4327,23 @@ function summarizeKnownAction(action) {
     case "session/reasoning" /* SessionReasoning */:
       return `reasoning "${clip(action.content, 60)}"`;
     case "session/ready" /* SessionReady */:
-      return `session ready ${shortId(action.session)}`;
+      return channel ? `session ready ${shortId(channel)}` : "session ready";
     case "terminal/data" /* TerminalData */:
-      return `terminal data ${shortId(action.terminal)} +${action.data.length}b`;
+      return channel ? `terminal data ${shortId(channel)} +${action.data.length}b` : `terminal data +${action.data.length}b`;
     case "terminal/commandFinished" /* TerminalCommandFinished */:
       return `terminal cmd done exit=${action.exitCode ?? "?"}`;
     default:
       return innerActionTypeAndDetail(toUnknownPayload(action));
   }
 }
+function summarizeToolCallDelta(action) {
+  const content = typeof action.content === "string" ? action.content : null;
+  return content === null ? `tool delta ${action.toolCallId}` : `tool delta ${action.toolCallId} +${content.length}b`;
+}
+function summarizeToolCallContentChanged(action) {
+  const content = Array.isArray(action.content) ? action.content : null;
+  return content === null ? `tool content ${action.toolCallId}` : `tool content ${action.toolCallId} (${content.length} parts)`;
+}
 function summarizeUnknownAction(action) {
   if (!action.type) return "action details unavailable";
   const t = action.type;
@@ -4680,6 +4775,9 @@ async function createAppState(opts) {
   const searchIdx = new SearchIndex();
   let seq = 0;
   let byteOffset = 0;
+  let initialReadLoadedBytes = 0;
+  let initialReadTotalBytes;
+  let initialReadPhase = "idle";
   function emit(payload) {
     for (const l of listeners) {
       try {
@@ -4688,6 +4786,22 @@ async function createAppState(opts) {
       }
     }
   }
+  function currentLoadProgress(phase = initialReadPhase) {
+    const totalBytes = initialReadTotalBytes;
+    const percent = totalBytes !== void 0 && totalBytes > 0 ? Math.min(100, Math.round(initialReadLoadedBytes / totalBytes * 100)) : void 0;
+    return {
+      kind: "load-progress",
+      phase,
+      loadedRows: rows.length,
+      loadedBytes: initialReadLoadedBytes,
+      ...totalBytes !== void 0 ? { totalBytes } : {},
+      ...percent !== void 0 ? { percent } : {}
+    };
+  }
+  function emitLoadProgress(phase) {
+    initialReadPhase = phase;
+    emit(currentLoadProgress());
+  }
   let lastSeenServerSeq = null;
   function buildRow(idx) {
     const ev = store.at(idx);
@@ -4717,6 +4831,30 @@ async function createAppState(opts) {
     };
     return projectRow(ev, idx, status, latency, extras, pairMethod);
   }
+  function buildPatchUpdates(indexes) {
+    const updates = [];
+    for (const idx of indexes) {
+      const prev = rows[idx];
+      if (!prev) continue;
+      const status = correlator.statusOf(idx);
+      const latencyMs = correlator.latencyOf(idx);
+      const pairIdx = correlator.pairOf(idx);
+      if (prev.status === status && prev.latencyMs === latencyMs && prev.pairIdx === pairIdx) {
+        continue;
+      }
+      const latencyBand = bandFor(latencyMs);
+      rows[idx] = { ...prev, status, latencyMs, latencyBand, pairIdx };
+      updates.push({
+        idx,
+        status,
+        latencyMs,
+        latencyBand,
+        ...prev.summary !== void 0 ? { summary: prev.summary } : {},
+        pairIdx
+      });
+    }
+    return updates;
+  }
   const offStore = store.subscribe((range) => {
     const newRows = [];
     for (let i = range.from; i < range.to; i++) {
@@ -4728,30 +4866,27 @@ async function createAppState(opts) {
         if (ev) searchIdx.append(ev);
       }
     }
-    const updates = [];
-    for (let i = 0; i < range.from; i++) {
-      const prev = rows[i];
-      if (!prev) continue;
-      const status = correlator.statusOf(i);
-      const latencyMs = correlator.latencyOf(i);
-      const pairIdx = correlator.pairOf(i);
-      if (prev.status !== status || prev.latencyMs !== latencyMs || prev.pairIdx !== pairIdx) {
-        const latencyBand = bandFor(latencyMs);
-        rows[i] = { ...prev, status, latencyMs, latencyBand, pairIdx };
-        updates.push({
-          idx: i,
-          status,
-          latencyMs,
-          latencyBand,
-          ...prev.summary !== void 0 ? { summary: prev.summary } : {},
-          pairIdx
-        });
-      }
-    }
+    const changedIndexes = correlator.drainChangedIndexes().filter((idx) => idx < range.from);
+    const updates = buildPatchUpdates(changedIndexes);
     if (newRows.length > 0) emit({ kind: "append", rows: newRows, from: range.from });
     if (updates.length > 0) emit({ kind: "patch", updates });
   });
   const watcher = opts.host.watchLog(handle, {
+    onInitialReadStart(info) {
+      initialReadLoadedBytes = 0;
+      initialReadTotalBytes = info.totalBytes;
+      emitLoadProgress("loading");
+    },
+    onInitialReadProgress(info) {
+      initialReadLoadedBytes = info.loadedBytes;
+      initialReadTotalBytes = info.totalBytes;
+      emitLoadProgress("loading");
+    },
+    onInitialReadComplete(info) {
+      initialReadLoadedBytes = info.loadedBytes;
+      initialReadTotalBytes = info.totalBytes;
+      emitLoadProgress("complete");
+    },
     onChunk(chunk, _byteOffset) {
       const text = decoder.decode(chunk, { stream: true });
       const newlineSize = text.includes("\r\n") ? 2 : 1;
@@ -4793,6 +4928,9 @@ async function createAppState(opts) {
       rows.length = 0;
       searchIdx.reset();
       lastSeenServerSeq = null;
+      initialReadLoadedBytes = 0;
+      initialReadTotalBytes = void 0;
+      emitLoadProgress("idle");
       emit({ kind: "rotation", newSize: info.newSize, reason: info.reason });
     },
     onError(err, fatal) {
@@ -4806,26 +4944,7 @@ async function createAppState(opts) {
   function runFlush(nowMs) {
     const now = nowMs ?? Date.now();
     correlator.flush(now, unmatchedTimeoutMs);
-    const updates = [];
-    for (let i = 0; i < store.size(); i++) {
-      const prev = rows[i];
-      if (!prev) continue;
-      const status = correlator.statusOf(i);
-      const latencyMs = correlator.latencyOf(i);
-      const pairIdx = correlator.pairOf(i);
-      if (prev.status !== status || prev.latencyMs !== latencyMs || prev.pairIdx !== pairIdx) {
-        const latencyBand = bandFor(latencyMs);
-        rows[i] = { ...prev, status, latencyMs, latencyBand, pairIdx };
-        updates.push({
-          idx: i,
-          status,
-          latencyMs,
-          latencyBand,
-          ...prev.summary !== void 0 ? { summary: prev.summary } : {},
-          pairIdx
-        });
-      }
-    }
+    const updates = buildPatchUpdates(correlator.drainChangedIndexes());
     if (updates.length > 0) emit({ kind: "patch", updates });
   }
   const flushIntervalMs = opts.flushIntervalMs ?? 1e3;
@@ -4835,7 +4954,7 @@ async function createAppState(opts) {
     meta,
     searchIndex: searchIdx,
     snapshot() {
-      return { meta, rows: rows.slice() };
+      return { meta, rows: rows.slice(), loadProgress: currentLoadProgress() };
     },
     subscribe(l) {
       listeners.add(l);
@@ -7881,30 +8000,17 @@ function registerLogRoutes(app, sessions) {
     }
     return streamSSE(c, async (stream2) => {
       const a = initial;
-      const snap = a.appState.snapshot();
-      await stream2.writeSSE({
-        event: "snapshot-begin",
-        data: JSON.stringify({ meta: snap.meta, total: snap.rows.length })
-      });
-      for (let i = 0; i < snap.rows.length; i += SNAPSHOT_CHUNK) {
-        if (stream2.aborted || stream2.closed) return;
-        const chunk = snap.rows.slice(i, i + SNAPSHOT_CHUNK);
-        await stream2.writeSSE({
-          event: "snapshot-chunk",
-          data: JSON.stringify({ rows: chunk, from: i })
-        });
-        await stream2.sleep(0);
-      }
-      if (stream2.aborted || stream2.closed) return;
-      await stream2.writeSSE({ event: "snapshot-end", data: "{}" });
       const queue = [];
+      let queueStart = 0;
       let pumping = false;
+      let snapshotStreaming = true;
+      const queuedFrameCount = () => queue.length - queueStart;
       const pump = async () => {
-        if (pumping) return;
+        if (pumping || snapshotStreaming) return;
         pumping = true;
         try {
-          while (queue.length > 0 && !stream2.aborted && !stream2.closed) {
-            const msg = queue.shift();
+          while (queuedFrameCount() > 0 && !stream2.aborted && !stream2.closed) {
+            const msg = queue[queueStart++];
             if (!msg) break;
             try {
               await stream2.writeSSE({ event: msg.kind, data: JSON.stringify(msg) });
@@ -7913,6 +8019,10 @@ function registerLogRoutes(app, sessions) {
             }
           }
         } finally {
+          if (queueStart === queue.length) {
+            queue.length = 0;
+            queueStart = 0;
+          }
           pumping = false;
         }
       };
@@ -7920,6 +8030,56 @@ function registerLogRoutes(app, sessions) {
         queue.push(msg);
         void pump();
       });
+      const snap = a.appState.snapshot();
+      await stream2.writeSSE({
+        event: "snapshot-begin",
+        data: JSON.stringify({ meta: snap.meta, total: snap.rows.length })
+      });
+      for (let i = 0; i < snap.rows.length; i += SNAPSHOT_CHUNK) {
+        if (stream2.aborted || stream2.closed) {
+          off();
+          return;
+        }
+        const chunk = snap.rows.slice(i, i + SNAPSHOT_CHUNK);
+        await stream2.writeSSE({
+          event: "snapshot-chunk",
+          data: JSON.stringify({ rows: chunk, from: i })
+        });
+        await stream2.sleep(0);
+      }
+      if (stream2.aborted || stream2.closed) {
+        off();
+        return;
+      }
+      await stream2.writeSSE({ event: "snapshot-end", data: "{}" });
+      if (snap.loadProgress.phase !== "idle") {
+        await stream2.writeSSE({
+          event: snap.loadProgress.kind,
+          data: JSON.stringify(snap.loadProgress)
+        });
+      }
+      snapshotStreaming = false;
+      if (queuedFrameCount() > 0) {
+        const queuedRows = queue.slice(queueStart).reduce((total, msg) => total + (msg.kind === "append" ? msg.rows.length : 0), 0);
+        const backlog = {
+          kind: "stream-backlog",
+          queuedFrames: queuedFrameCount(),
+          queuedRows
+        };
+        await stream2.writeSSE({ event: backlog.kind, data: JSON.stringify(backlog) });
+        await pump();
+        const clearedBacklog = {
+          kind: "stream-backlog",
+          queuedFrames: 0,
+          queuedRows: 0
+        };
+        await stream2.writeSSE({
+          event: clearedBacklog.kind,
+          data: JSON.stringify(clearedBacklog)
+        });
+      } else {
+        await pump();
+      }
       let endRequested = false;
       const offChange = sessions.onChange(async () => {
         if (endRequested) return;