@cryptiklemur/lattice 1.43.5 → 1.43.7

package/client/src/components/chat/ChatView.tsx

@@ -23,7 +23,7 @@ import { useBookmarks } from "../../hooks/useBookmarks";
 import { formatSessionTitle } from "../../utils/formatSessionTitle";
 
 export function ChatView({ sessionId: tabSessionId, projectSlug: tabProjectSlug }: { sessionId?: string; projectSlug?: string } = {}) {
-  var { messages, isProcessing, sendMessage, activeSessionId, activeSessionTitle, currentStatus, contextUsage, contextBreakdown, lastResponseCost, lastResponseDuration, historyLoading, wasInterrupted, promptSuggestion, failedInput, clearFailedInput, messageQueue, enqueueMessage, removeQueuedMessage, updateQueuedMessage, isBusy, busyOwner, isPlanMode, pendingPrefill, activateSession, budgetStatus, budgetExceeded, sendBudgetOverride, dismissBudgetExceeded } = useSession();
+  var { messages, isProcessing, sendMessage, activeSessionId, activeSessionTitle, currentStatus, contextUsage, contextBreakdown, lastResponseCost, lastResponseDuration, historyLoading, historyHasMore, loadMoreHistory, wasInterrupted, promptSuggestion, failedInput, clearFailedInput, messageQueue, enqueueMessage, removeQueuedMessage, updateQueuedMessage, isBusy, busyOwner, isPlanMode, pendingPrefill, activateSession, budgetStatus, budgetExceeded, sendBudgetOverride, dismissBudgetExceeded } = useSession();
   var { activeProject } = useProjects();
   var { toggleDrawer } = useSidebar();
 
@@ -735,6 +735,16 @@ export function ChatView({ sessionId: tabSessionId, projectSlug: tabProjectSlug
         aria-relevant="additions"
         style={{ WebkitOverflowScrolling: "touch", touchAction: "pan-y" }}
       >
+        {historyHasMore && messages.length > 0 && (
+          <div className="flex justify-center py-3">
+            <button
+              onClick={loadMoreHistory}
+              className="text-[11px] text-base-content/30 hover:text-base-content/50 font-mono transition-colors"
+            >
+              Load older messages
+            </button>
+          </div>
+        )}
         {messages.length === 0 && historyLoading ? (
           <div className="flex items-center justify-center h-full">
             <div className="flex flex-col items-center gap-3">

package/client/src/hooks/useSession.ts

@@ -78,6 +78,8 @@ export interface UseSessionReturn extends SessionState {
   clearMessageQueue: () => void;
   sendBudgetOverride: () => void;
   dismissBudgetExceeded: () => void;
+  loadMoreHistory: () => void;
+  historyHasMore: boolean;
 }
 
 export function useSession(): UseSessionReturn {
@@ -276,6 +278,19 @@ export function useSession(): UseSessionReturn {
       updatePermissionStatus(m.requestId, m.status);
     }
 
+    function handleHistoryPage(msg: ServerMessage) {
+      var m = msg as { type: string; sessionId: string; messages: HistoryMessage[]; hasMore: boolean };
+      var state = getSessionStore().state;
+      if (m.sessionId !== state.activeSessionId) return;
+      getSessionStore().setState(function (s) {
+        return {
+          ...s,
+          messages: mergeToolResults(m.messages).concat(s.messages),
+          historyHasMore: m.hasMore,
+        };
+      });
+    }
+
     function handleHistory(msg: ServerMessage) {
       var m = msg as SessionHistoryMessage;
       setCurrentAssistantUuid(null);
@@ -303,6 +318,8 @@ export function useSession(): UseSessionReturn {
             lastResponseDuration: null,
             lastReadIndex: null,
             historyLoading: false,
+            historyHasMore: m.hasMore || false,
+            historyTotalMessages: m.totalMessages || m.messages.length,
             wasInterrupted: m.interrupted || false,
             isBusy: m.busy || false,
             busyOwner: m.busyOwner ?? null,
@@ -390,6 +407,7 @@ export function useSession(): UseSessionReturn {
     subscribe("chat:context_usage", handleContextUsage);
     subscribe("chat:context_breakdown", handleContextBreakdown);
     subscribe("session:history", handleHistory);
+    subscribe("session:history_page_result", handleHistoryPage);
     subscribe("chat:prompt_suggestion", handlePromptSuggestion);
     subscribe("session:busy", handleSessionBusy);
     subscribe("chat:prompt_request", handlePromptRequest);
@@ -413,6 +431,7 @@ export function useSession(): UseSessionReturn {
       unsubscribe("chat:context_usage", handleContextUsage);
       unsubscribe("chat:context_breakdown", handleContextBreakdown);
       unsubscribe("session:history", handleHistory);
+      unsubscribe("session:history_page_result", handleHistoryPage);
       unsubscribe("chat:prompt_suggestion", handlePromptSuggestion);
       unsubscribe("session:busy", handleSessionBusy);
       unsubscribe("chat:prompt_request", handlePromptRequest);
@@ -441,6 +460,15 @@ export function useSession(): UseSessionReturn {
     lastResponseDuration: state.lastResponseDuration,
     lastReadIndex: state.lastReadIndex,
     historyLoading: state.historyLoading,
+    historyHasMore: state.historyHasMore,
+    historyTotalMessages: state.historyTotalMessages,
+    loadMoreHistory: function () {
+      if (!state.historyHasMore || !state.activeSessionId) return;
+      var totalMessages = state.historyTotalMessages;
+      var loadedCount = state.messages.length;
+      var beforeIndex = totalMessages - loadedCount;
+      sendRef.current({ type: "session:history_page", sessionId: state.activeSessionId, before: beforeIndex, limit: 100 } as any);
+    },
     wasInterrupted: state.wasInterrupted,
     promptSuggestion: state.promptSuggestion,
     failedInput: state.failedInput,

package/client/src/stores/session.ts

@@ -42,6 +42,8 @@ export interface SessionState {
   lastResponseDuration: number | null;
   lastReadIndex: number | null;
   historyLoading: boolean;
+  historyHasMore: boolean;
+  historyTotalMessages: number;
   wasInterrupted: boolean;
   promptSuggestion: string | null;
   failedInput: string | null;
@@ -68,6 +70,8 @@ var sessionStore = new Store<SessionState>({
   lastResponseDuration: null,
   lastReadIndex: null,
   historyLoading: false,
+  historyHasMore: false,
+  historyTotalMessages: 0,
   wasInterrupted: false,
   promptSuggestion: null,
   failedInput: null,
@@ -293,6 +297,8 @@ export function clearSession(): void {
       lastResponseDuration: null,
       lastReadIndex: null,
       historyLoading: false,
+      historyHasMore: false,
+      historyTotalMessages: 0,
       wasInterrupted: false,
       promptSuggestion: null,
       failedInput: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "1.43.5",
+  "version": "1.43.7",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",

package/server/src/handlers/session.ts

@@ -20,11 +20,12 @@ import {
   getSessionUsage,
   listSessions,
   invalidateSessionCache,
+  getSessionHistoryPage,
   loadSessionHistory,
   renameSession,
 } from "../project/session";
 import { getContextBreakdown } from "../project/context-breakdown";
-import { setActiveSession } from "./chat";
+import { setActiveSession, getActiveSession } from "./chat";
 import { setActiveProject } from "./fs";
 import { wasSessionInterrupted, clearInterruptedFlag, isSessionBusy, watchSessionLock, stopExternalSession, getBusyOwner } from "../project/sdk-bridge";
 import { log } from "../logger";
@@ -79,6 +80,20 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     return;
   }
 
+  if (message.type === "session:history_page") {
+    var pageMsg = message as { type: "session:history_page"; sessionId: string; before: number; limit: number };
+    var activeSession = getActiveSession(clientId);
+    void getSessionHistoryPage(pageMsg.sessionId, pageMsg.before, pageMsg.limit, activeSession?.projectSlug).then(function (page) {
+      sendTo(clientId, {
+        type: "session:history_page_result",
+        sessionId: pageMsg.sessionId,
+        messages: page.messages,
+        hasMore: page.hasMore,
+      });
+    });
+    return;
+  }
+
   if (message.type === "session:create") {
     var createMsg = message as SessionCreateMessage;
     var session = createSession(createMsg.projectSlug);
@@ -91,47 +106,42 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
     setActiveSession(clientId, activateMsg.projectSlug, activateMsg.sessionId);
     setActiveProject(clientId, activateMsg.projectSlug);
     watchSessionLock(activateMsg.sessionId);
+    var activateT0 = Date.now();
+    void loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId).then(function (historyResult) {
+      log.session("session:activate total history load: %dms", Date.now() - activateT0);
+      var interrupted = wasSessionInterrupted(activateMsg.sessionId);
+      if (interrupted) {
+        clearInterruptedFlag(activateMsg.sessionId);
+      }
+      var busy = isSessionBusy(activateMsg.sessionId);
+      var busyOwner = busy ? getBusyOwner(activateMsg.sessionId) : undefined;
+      sendTo(clientId, {
+        type: "session:history",
+        projectSlug: activateMsg.projectSlug,
+        sessionId: activateMsg.sessionId,
+        messages: historyResult.messages,
+        title: null,
+        interrupted: interrupted || undefined,
+        busy: busy || undefined,
+        busyOwner: busyOwner,
+        totalMessages: historyResult.totalMessages,
+        hasMore: historyResult.hasMore,
+      });
+    }).catch(function (err) {
+      log.session("Error sending session history: %O", err);
+      sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
+    });
+
     void Promise.all([
-      loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load session history: %O", err);
-        return null;
-      }),
-      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load session title: %O", err);
-        return null;
-      }),
-      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load session usage: %O", err);
-        return null;
-      }),
-      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function (err) {
-        log.session("Failed to load context breakdown: %O", err);
-        return null;
-      }),
+      getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+      getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+      getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
     ]).then(function (results) {
       try {
-        var interrupted = wasSessionInterrupted(activateMsg.sessionId);
-        if (interrupted) {
-          clearInterruptedFlag(activateMsg.sessionId);
+        if (results[0]) {
+          sendTo(clientId, { type: "session:history", projectSlug: activateMsg.projectSlug, sessionId: activateMsg.sessionId, messages: [], title: results[0] as string });
         }
-        var busy = isSessionBusy(activateMsg.sessionId);
-        var busyOwner = busy ? getBusyOwner(activateMsg.sessionId) : undefined;
-        sendTo(clientId, {
-          type: "session:history",
-          projectSlug: activateMsg.projectSlug,
-          sessionId: activateMsg.sessionId,
-          messages: results[0] || [],
-          title: results[1],
-          interrupted: interrupted || undefined,
-          busy: busy || undefined,
-          busyOwner: busyOwner,
-        });
-      } catch (err) {
-        log.session("Error sending session history: %O", err);
-        sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
-      }
-      try {
-        var usage = results[2];
+        var usage = results[1];
         if (usage) {
           sendTo(clientId, {
             type: "chat:context_usage",
@@ -146,7 +156,7 @@ registerHandler("session", function (clientId: string, message: ClientMessage) {
         log.session("Error sending context usage: %O", err);
       }
       try {
-        var breakdown = results[3];
+        var breakdown = results[2];
         if (breakdown) {
           sendTo(clientId, {
             type: "chat:context_breakdown",

package/server/src/project/session.ts

@@ -457,19 +457,121 @@ export async function getSessionTitle(projectSlug: string, sessionId: string): P
   return "Untitled";
 }
 
-export async function loadSessionHistory(projectSlug: string, sessionId: string): Promise<HistoryMessage[]> {
+var historyCache = new Map<string, { messages: HistoryMessage[]; time: number }>();
+var HISTORY_CACHE_TTL = 60000;
+var INITIAL_MESSAGE_COUNT = 100;
+var TAIL_READ_BYTES = 2 * 1024 * 1024;
+
+function getSessionFilePath(projectSlug: string, sessionId: string): string | null {
   var projectPath = getProjectPath(projectSlug);
-  var options = projectPath ? { dir: projectPath } : undefined;
+  if (!projectPath) return null;
+  var hash = projectPathToHash(projectPath);
+  var filePath = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+  return existsSync(filePath) ? filePath : null;
+}
+
+function readTailLines(filePath: string, maxBytes: number): { lines: string[]; isPartial: boolean; fileSize: number } {
+  var { openSync, readSync, fstatSync, closeSync } = require("node:fs") as typeof import("node:fs");
+  var fd = openSync(filePath, "r");
+  var stat = fstatSync(fd);
+  var readStart = Math.max(0, stat.size - maxBytes);
+  var buf = Buffer.alloc(stat.size - readStart);
+  readSync(fd, buf, 0, buf.length, readStart);
+  closeSync(fd);
+  var text = buf.toString("utf-8");
+  if (readStart > 0) {
+    var firstNewline = text.indexOf("\n");
+    if (firstNewline >= 0) text = text.slice(firstNewline + 1);
+  }
+  var lines = text.split("\n").filter(function (l) { return l.length > 0; });
+  return { lines, isPartial: readStart > 0, fileSize: stat.size };
+}
 
+function parseJsonlLines(lines: string[]): SessionMessage[] {
+  var results: SessionMessage[] = [];
+  for (var i = 0; i < lines.length; i++) {
+    try {
+      var parsed = JSON.parse(lines[i]);
+      if (parsed.type === "user" || parsed.type === "assistant" || parsed.type === "system") {
+        results.push(parsed as SessionMessage);
+      }
+    } catch {}
+  }
+  return results;
+}
+
+export async function loadSessionHistory(projectSlug: string, sessionId: string): Promise<{ messages: HistoryMessage[]; totalMessages: number; hasMore: boolean }> {
   try {
-    var messages = await getSessionMessages(sessionId, options);
-    return convertSessionMessages(messages);
+    var t0 = Date.now();
+    var cached = historyCache.get(sessionId);
+    if (cached && Date.now() - cached.time < HISTORY_CACHE_TTL) {
+      var tail = cached.messages.length > INITIAL_MESSAGE_COUNT
+        ? cached.messages.slice(cached.messages.length - INITIAL_MESSAGE_COUNT)
+        : cached.messages;
+      log.session("loadSessionHistory %s: %dms (cached, %d total)", sessionId.slice(0, 8), Date.now() - t0, cached.messages.length);
+      return { messages: tail, totalMessages: cached.messages.length, hasMore: cached.messages.length > INITIAL_MESSAGE_COUNT };
+    }
+
+    var filePath = getSessionFilePath(projectSlug, sessionId);
+    if (filePath) {
+      var tailData = readTailLines(filePath, TAIL_READ_BYTES);
+      var tailRaw = parseJsonlLines(tailData.lines);
+      var tailMessages = convertSessionMessages(tailRaw);
+      var hasMore = tailData.isPartial;
+
+      log.session("loadSessionHistory %s: %dms (tail read, %d msgs, partial=%s)", sessionId.slice(0, 8), Date.now() - t0, tailMessages.length, hasMore);
+
+      if (!hasMore) {
+        historyCache.set(sessionId, { messages: tailMessages, time: Date.now() });
+      }
+
+      var initialSlice = tailMessages.length > INITIAL_MESSAGE_COUNT
+        ? tailMessages.slice(tailMessages.length - INITIAL_MESSAGE_COUNT)
+        : tailMessages;
+
+      return { messages: initialSlice, totalMessages: tailMessages.length, hasMore: hasMore };
+    }
+
+    var projectPath = getProjectPath(projectSlug);
+    var options = projectPath ? { dir: projectPath } : undefined;
+    var rawMessages = await getSessionMessages(sessionId, options);
+    var allMessages = convertSessionMessages(rawMessages);
+    historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
+    log.session("loadSessionHistory %s: %dms (full SDK, %d msgs)", sessionId.slice(0, 8), Date.now() - t0, allMessages.length);
+    var tailSlice = allMessages.length > INITIAL_MESSAGE_COUNT
+      ? allMessages.slice(allMessages.length - INITIAL_MESSAGE_COUNT)
+      : allMessages;
+    return { messages: tailSlice, totalMessages: allMessages.length, hasMore: allMessages.length > INITIAL_MESSAGE_COUNT };
   } catch (err) {
     log.session("Failed to load session history: %O", err);
-    return [];
+    return { messages: [], totalMessages: 0, hasMore: false };
   }
 }
 
+export async function getSessionHistoryPage(sessionId: string, beforeIndex: number, limit: number, projectSlug?: string): Promise<{ messages: HistoryMessage[]; hasMore: boolean }> {
+  var cached = historyCache.get(sessionId);
+  if (!cached && projectSlug) {
+    var projectPath = getProjectPath(projectSlug);
+    var options = projectPath ? { dir: projectPath } : undefined;
+    try {
+      var rawMessages = await getSessionMessages(sessionId, options);
+      var allMessages = convertSessionMessages(rawMessages);
+      historyCache.set(sessionId, { messages: allMessages, time: Date.now() });
+      cached = { messages: allMessages, time: Date.now() };
+      log.session("getSessionHistoryPage: full load for %s, %d messages", sessionId.slice(0, 8), allMessages.length);
+    } catch {
+      return { messages: [], hasMore: false };
+    }
+  }
+  if (!cached) return { messages: [], hasMore: false };
+
+  var endIdx = Math.max(0, beforeIndex);
+  var startIdx = Math.max(0, endIdx - limit);
+  var page = cached.messages.slice(startIdx, endIdx);
+
+  return { messages: page, hasMore: startIdx > 0 };
+}
+
 export function createSession(projectSlug: string): SessionSummary {
   var sessionId = randomUUID();
   var now = Date.now();

package/shared/src/messages.ts

@@ -50,6 +50,20 @@ export interface SessionListRequestMessage {
   limit?: number;
 }
 
+export interface SessionHistoryPageMessage {
+  type: "session:history_page";
+  sessionId: string;
+  before: number;
+  limit: number;
+}
+
+export interface SessionHistoryPageResultMessage {
+  type: "session:history_page_result";
+  sessionId: string;
+  messages: HistoryMessage[];
+  hasMore: boolean;
+}
+
 export interface SessionPreviewRequestMessage {
   type: "session:preview_request";
   projectSlug: string;
@@ -578,6 +592,7 @@ export type ClientMessage =
   | EditorEnsureProjectMessage
   | ChatPromptResponseMessage
   | AnalyticsRequestMessage
+  | SessionHistoryPageMessage
   | SessionPreviewRequestMessage
   | BookmarkListMessage
   | BookmarkAddMessage
@@ -623,6 +638,8 @@ export interface SessionHistoryMessage {
   interrupted?: boolean;
   busy?: boolean;
   busyOwner?: "cli" | "lattice";
+  totalMessages?: number;
+  hasMore?: boolean;
 }
 
 export interface SessionBusyMessage {
@@ -1076,6 +1093,7 @@ export type ServerMessage =
   | AnalyticsDataMessage
   | AnalyticsErrorMessage
   | SessionPreviewMessage
+  | SessionHistoryPageResultMessage
   | BookmarkListResultMessage
   | BudgetStatusMessage
   | BudgetExceededMessage