ocwatch 0.5.0 → 0.6.0

package/src/server/services/pollService.ts

@@ -9,6 +9,7 @@ import type {
   ActivitySession,
   PartMeta,
   TodoItem,
+  SessionActivityResponse,
 } from "../../shared/types";
 import { parseBoulder, calculatePlanProgress } from "../storage/boulderParser";
 import {
@@ -16,7 +17,11 @@ import {
   queryMaxTimestamp,
   queryMessages,
   queryParts,
+  queryMessagesForSessions,
+  queryPartsForSessions,
   querySessions,
+  querySessionSubtree,
+  querySessionSubtreeRevision,
   queryTodos,
 } from "../storage";
 import {
@@ -27,6 +32,7 @@ import {
   isAssistantFinished,
 } from "../logic";
 import { resolveProjectDirectory } from "../utils/projectResolver";
+import { createSessionContext } from "./sessionContext";
 import { getSessionHierarchy } from "./sessionService";
 import { aggregateSessionStats } from "./statsService";
 import {
@@ -36,16 +42,14 @@ import {
   getLatestAssistantMessage,
   getMostRecentPendingPart,
 } from "./parsing";
+import { selectRecentRootSessions } from "./recentSessions";
 import {
-  TWENTY_FOUR_HOURS_MS,
   MAX_SESSIONS_LIMIT,
   MAX_MESSAGES_LIMIT,
   POLL_CACHE_TTL_MS,
+  SESSION_SCAN_LIMIT,
+  MESSAGE_SCAN_LIMIT,
 } from "../../shared/constants";
-/** Max sessions to scan when building incremental state (internal upper bound) */
-const SESSION_SCAN_LIMIT = 50_000;
-/** Max messages per session for incremental poll cache (high to avoid missing updates) */
-const MESSAGE_SCAN_LIMIT = 10_000;
 
 interface IncrementalPollState {
   sessionsById: Map<string, SessionMetadata>;
@@ -72,10 +76,27 @@ export function generateETag(data: PollResponse): string {
   return `"${hash.substring(0, 16)}"`;
 }
 
+export function generateSessionActivityETag(data: SessionActivityResponse): string {
+  const hash = createHash("sha256")
+    .update(
+      JSON.stringify({
+        revision: data.revision,
+        session: data.session,
+        activity: data.activity,
+        stats: data.stats,
+      }),
+    )
+    .digest("hex");
+  return `"${hash.substring(0, 16)}"`;
+}
+
 type PollCacheEntry = { data: PollResponse; etag: string; timestamp: number };
+type SessionActivityCacheEntry = { data: SessionActivityResponse; etag: string };
 
 const pollCacheMap = new Map<string, PollCacheEntry>();
 const pollInProgressMap = new Map<string, Promise<PollResponse>>();
+const sessionActivityCacheMap = new Map<string, SessionActivityCacheEntry>();
+const sessionActivityInProgressMap = new Map<string, Promise<SessionActivityResponse>>();
 const incrementalPollStateMap = new Map<string, IncrementalPollState>();
 const MAX_INCREMENTAL_STATE_ENTRIES = 10;
 let pollCacheEpoch = 0;
@@ -84,6 +105,10 @@ function cacheKey(projectId?: string): string {
   return projectId ?? "";
 }
 
+function sessionActivityCacheKey(sessionId: string): string {
+  return sessionId;
+}
+
 export function getPollCache(projectId?: string): PollCacheEntry | null {
   return pollCacheMap.get(cacheKey(projectId)) ?? null;
 }
@@ -104,6 +129,7 @@ export function getPollCacheEpoch() {
 export function invalidatePollCache() {
   pollCacheEpoch += 1;
   pollCacheMap.clear();
+  sessionActivityCacheMap.clear();
 }
 
 export function getPollInProgress(projectId?: string): Promise<PollResponse> | null {
@@ -119,6 +145,32 @@ export function setPollInProgress(promise: Promise<PollResponse> | null, project
   }
 }
 
+export function getSessionActivityCache(sessionId: string): SessionActivityCacheEntry | null {
+  return sessionActivityCacheMap.get(sessionActivityCacheKey(sessionId)) ?? null;
+}
+
+export function setSessionActivityCache(sessionId: string, cache: SessionActivityCacheEntry | null) {
+  const key = sessionActivityCacheKey(sessionId);
+  if (cache) {
+    sessionActivityCacheMap.set(key, cache);
+  } else {
+    sessionActivityCacheMap.delete(key);
+  }
+}
+
+export function getSessionActivityInProgress(sessionId: string): Promise<SessionActivityResponse> | null {
+  return sessionActivityInProgressMap.get(sessionActivityCacheKey(sessionId)) ?? null;
+}
+
+export function setSessionActivityInProgress(sessionId: string, promise: Promise<SessionActivityResponse> | null) {
+  const key = sessionActivityCacheKey(sessionId);
+  if (promise) {
+    sessionActivityInProgressMap.set(key, promise);
+  } else {
+    sessionActivityInProgressMap.delete(key);
+  }
+}
+
 export function getPollCacheTTL() {
   return POLL_CACHE_TTL_MS;
 }
@@ -159,6 +211,38 @@ function sortMessagesDescending(messages: MessageMeta[]): MessageMeta[] {
   return [...messages].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
 }
 
+function groupMessagesBySession(rows: ReturnType<typeof queryMessagesForSessions>): Map<string, MessageMeta[]> {
+  const grouped = new Map<string, MessageMeta[]>();
+
+  for (const row of rows) {
+    const parsed = toMessageMeta(row);
+    const existing = grouped.get(parsed.sessionID);
+    if (existing) {
+      existing.push(parsed);
+    } else {
+      grouped.set(parsed.sessionID, [parsed]);
+    }
+  }
+
+  return grouped;
+}
+
+function groupPartsBySession(rows: ReturnType<typeof queryPartsForSessions>): Map<string, PartMeta[]> {
+  const grouped = new Map<string, PartMeta[]>();
+
+  for (const row of rows) {
+    const parsed = toPartMeta(row);
+    const existing = grouped.get(parsed.sessionID);
+    if (existing) {
+      existing.push(parsed);
+    } else {
+      grouped.set(parsed.sessionID, [parsed]);
+    }
+  }
+
+  return grouped;
+}
+
 function loadMessagesForSession(state: IncrementalPollState, sessionId: string, forceRefresh = false): MessageMeta[] {
   if (!forceRefresh) {
     const cached = state.messagesBySessionId.get(sessionId);
@@ -229,7 +313,8 @@ function updateIncrementalState(state: IncrementalPollState, projectId?: string)
     }
   }
 
-  if (changedSessionIds.size > 0) {
+  const wasFirstLoad = !hasBaseline || refreshAllSessions;
+  if (!wasFirstLoad && changedSessionIds.size > 0) {
     for (const sessionId of changedSessionIds) {
       loadMessagesForSession(state, sessionId, true);
       loadPartsForSession(state, sessionId, true);
@@ -262,12 +347,8 @@ export async function fetchPollData(projectId?: string): Promise<PollResponse> {
   }
 
   const now = Date.now();
-  const twentyFourHoursAgo = now - TWENTY_FOUR_HOURS_MS;
 
-  const recentSessions = scopedSessions.filter((session) => session.updatedAt.getTime() >= twentyFourHoursAgo);
-  const sortedSessions = recentSessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-  const limitedSessions = sortedSessions.slice(0, MAX_SESSIONS_LIMIT);
-  const rootSessions = limitedSessions.filter((session) => !session.parentID);
+  const rootSessions = selectRecentRootSessions(scopedSessions, MAX_SESSIONS_LIMIT);
 
   function getCachedMessages(id: string): MessageMeta[] {
     const cached = state.messagesBySessionId.get(id);
@@ -348,7 +429,7 @@ export async function fetchPollData(projectId?: string): Promise<PollResponse> {
         planName = boulder.planName || undefined;
       }
     } catch (err) {
-      console.debug("Failed to parse boulder.json:", err instanceof Error ? err.message : err);
+      console.warn("Failed to parse boulder.json:", err instanceof Error ? err.message : err);
     }
   }
 
@@ -375,44 +456,36 @@ export async function fetchPollData(projectId?: string): Promise<PollResponse> {
   };
 }
 
-export async function fetchSessionDetail(sessionId: string): Promise<SessionDetail> {
-  // Get all sessions for hierarchy context
-  const allSessions = querySessions(undefined, undefined, SESSION_SCAN_LIMIT).map(toSessionMetadata);
-
-  // Get messages for this session
-  const messages = queryMessages(sessionId, MAX_MESSAGES_LIMIT).map(toMessageMeta);
-
-  // Get activity tree (hierarchy)
-  const activity: ActivitySession[] = await getSessionHierarchy(sessionId, allSessions);
-
-  // Build messages cache for stats
-  const messagesCache = new Map<string, MessageMeta[]>();
-  messagesCache.set(sessionId, messages);
-  for (const activitySession of activity) {
-    if (!messagesCache.has(activitySession.id) && !activitySession.id.includes("-phase-")) {
-      const childMessages = queryMessages(activitySession.id, MAX_MESSAGES_LIMIT).map(toMessageMeta);
-      messagesCache.set(activitySession.id, childMessages);
+async function buildSessionActivityResponse(sessionId: string): Promise<{
+  graph: SessionActivityResponse;
+  messagesBySession: Map<string, MessageMeta[]>;
+}> {
+  const allSessions = querySessionSubtree(sessionId).map(toSessionMetadata);
+  const sessionIds = allSessions.map((session) => session.id);
+  const messagesBySession = groupMessagesBySession(
+    queryMessagesForSessions(sessionIds, MESSAGE_SCAN_LIMIT),
+  );
+  const partsBySession = groupPartsBySession(queryPartsForSessions(sessionIds));
+  const context = createSessionContext(allSessions, {
+    messagesBySession,
+    partsBySession,
+  });
+
+  for (const session of allSessions) {
+    if (!messagesBySession.has(session.id)) {
+      messagesBySession.set(session.id, []);
+    }
+    if (!partsBySession.has(session.id)) {
+      partsBySession.set(session.id, []);
     }
   }
 
-  // Get todos
-  const todos: TodoItem[] = queryTodos(sessionId).map((row) => ({
-    content: row.content,
-    status: row.status,
-    priority: row.priority,
-    position: row.position,
-  }));
-
-  // Compute stats
-  const stats = aggregateSessionStats(activity, messagesCache);
-
-  // Find the session metadata
-  const sessionMeta = allSessions.find((s) => s.id === sessionId);
-
-  // Find the root activity entry for derived status (direct match or last phase)
+  const activity: ActivitySession[] = await getSessionHierarchy(sessionId, allSessions, context);
+  const stats = aggregateSessionStats(activity, messagesBySession);
+  const sessionMeta = allSessions.find((session) => session.id === sessionId);
   const rootActivity =
-    activity.find((a) => a.id === sessionId) ??
-    activity.filter((a) => a.id.startsWith(`${sessionId}-phase-`)).pop();
+    activity.find((activitySession) => activitySession.id === sessionId) ??
+    activity.filter((activitySession) => activitySession.id.startsWith(`${sessionId}-phase-`)).pop();
 
   const session: SessionSummary = {
     id: sessionId,
@@ -428,5 +501,38 @@ export async function fetchSessionDetail(sessionId: string): Promise<SessionDeta
     createdAt: sessionMeta?.createdAt ?? new Date(),
   };
 
-  return { session, messages, activity, todos, stats };
+  return {
+    graph: {
+      session,
+      activity,
+      stats,
+      revision: querySessionSubtreeRevision(sessionId),
+    },
+    messagesBySession,
+  };
+}
+
+export async function fetchSessionActivity(sessionId: string): Promise<SessionActivityResponse> {
+  return (await buildSessionActivityResponse(sessionId)).graph;
+}
+
+export async function fetchSessionDetail(sessionId: string): Promise<SessionDetail> {
+  const { graph, messagesBySession } = await buildSessionActivityResponse(sessionId);
+
+  const todos: TodoItem[] = queryTodos(sessionId).map((row) => ({
+    content: row.content,
+    status: row.status,
+    priority: row.priority,
+    position: row.position,
+  }));
+
+  const messages = (messagesBySession.get(sessionId) ?? []).slice(0, MAX_MESSAGES_LIMIT);
+
+  return {
+    session: graph.session,
+    messages,
+    activity: graph.activity,
+    todos,
+    stats: graph.stats ?? undefined,
+  };
 }

package/src/server/services/recentSessions.ts

@@ -0,0 +1,14 @@
+interface HasRootSessionFields {
+  parentID?: string | null;
+  updatedAt: Date;
+}
+
+export function selectRecentRootSessions<T extends HasRootSessionFields>(
+  sessions: readonly T[],
+  limit: number,
+): T[] {
+  return sessions
+    .filter((session) => !session.parentID)
+    .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
+    .slice(0, limit);
+}

package/src/server/services/sessionContext.ts

@@ -0,0 +1,97 @@
+import type { SessionMetadata, MessageMeta, PartMeta } from "../../shared/types";
+import { MESSAGE_SCAN_LIMIT } from "../../shared/constants";
+import {
+  queryMessages,
+  queryParts,
+} from "../storage/queries";
+import {
+  toMessageMeta as parseMessageRow,
+  toPartMeta as parsePartRow,
+} from "./parsing";
+
+export interface SessionContext {
+  allowedSessionIds: Set<string>;
+  sessionById: Map<string, SessionMetadata>;
+  messagesBySession: Map<string, MessageMeta[]>;
+  partsBySession: Map<string, PartMeta[]>;
+  childrenBySession: Map<string, SessionMetadata[]>;
+}
+
+interface SessionContextSeed {
+  messagesBySession?: Map<string, MessageMeta[]>;
+  partsBySession?: Map<string, PartMeta[]>;
+}
+
+export function createSessionContext(allSessions: SessionMetadata[], seed: SessionContextSeed = {}): SessionContext {
+  const sessionById = new Map<string, SessionMetadata>();
+  const childrenBySession = new Map<string, SessionMetadata[]>();
+  for (const session of allSessions) {
+    sessionById.set(session.id, session);
+    if (!session.parentID) {
+      continue;
+    }
+
+    const siblings = childrenBySession.get(session.parentID);
+    if (siblings) {
+      siblings.push(session);
+    } else {
+      childrenBySession.set(session.parentID, [session]);
+    }
+  }
+
+  for (const children of childrenBySession.values()) {
+    children.sort((a, b) => {
+      const createdDiff = a.createdAt.getTime() - b.createdAt.getTime();
+      if (createdDiff !== 0) {
+        return createdDiff;
+      }
+
+      return a.id.localeCompare(b.id);
+    });
+  }
+
+  return {
+    allowedSessionIds: new Set(allSessions.map((session) => session.id)),
+    sessionById,
+    messagesBySession: new Map<string, MessageMeta[]>(seed.messagesBySession),
+    partsBySession: new Map<string, PartMeta[]>(seed.partsBySession),
+    childrenBySession,
+  };
+}
+
+export function getSessionFromContext(sessionId: string, context: SessionContext): SessionMetadata | undefined {
+  return context.sessionById.get(sessionId);
+}
+
+export function getSessionMessages(sessionId: string, context: SessionContext): MessageMeta[] {
+  const cached = context.messagesBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
+
+  const messages = queryMessages(sessionId, MESSAGE_SCAN_LIMIT).map(parseMessageRow);
+  context.messagesBySession.set(sessionId, messages);
+  return messages;
+}
+
+export function getSessionParts(sessionId: string, context: SessionContext): PartMeta[] {
+  const cached = context.partsBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
+
+  const parts = queryParts(sessionId).map(parsePartRow);
+  context.partsBySession.set(sessionId, parts);
+  return parts;
+}
+
+export function getSessionChildren(sessionId: string, context: SessionContext): SessionMetadata[] {
+  const cached = context.childrenBySession.get(sessionId);
+  if (cached) {
+    return cached;
+  }
+
+  const children: SessionMetadata[] = [];
+  context.childrenBySession.set(sessionId, children);
+  return children;
+}

package/src/server/services/sessionService.ts

@@ -1,10 +1,6 @@
 import type {
   SessionMetadata,
-  MessageMeta,
   ActivitySession,
-  TreeNode,
-  TreeEdge,
-  SessionTree,
   PartMeta,
   SessionStatus,
   ToolCallSummary,
@@ -21,95 +17,22 @@ import {
   getSessionStatusInfo,
   type SessionStatusInfo,
 } from "../logic";
-import {
-  querySessionChildren,
-  queryMessages,
-  queryParts,
-} from "../storage/queries";
 import { getStatusFromTimestamp } from "../utils/sessionStatus";
 import {
-  toSessionMetadata as parseSessionRow,
-  toMessageMeta as parseMessageRow,
-  toPartMeta as parsePartRow,
   getLatestAssistantMessage,
   getMostRecentPendingPart,
 } from "./parsing";
+import {
+  type SessionContext,
+  createSessionContext,
+  getSessionFromContext,
+  getSessionMessages,
+  getSessionParts,
+  getSessionChildren,
+} from "./sessionContext";
 
 export { detectAgentPhases, isAssistantFinished };
 
-/** Max messages to load per session for hierarchy building (effectively unlimited) */
-const MAX_MESSAGE_QUERY_LIMIT = 100_000;
-
-interface SessionContext {
-  allowedSessionIds: Set<string>;
-  sessionById: Map<string, SessionMetadata>;
-  messagesBySession: Map<string, MessageMeta[]>;
-  partsBySession: Map<string, PartMeta[]>;
-  childrenBySession: Map<string, SessionMetadata[]>;
-}
-
-
-function createSessionContext(allSessions: SessionMetadata[]): SessionContext {
-  const sessionById = new Map<string, SessionMetadata>();
-  for (const session of allSessions) {
-    sessionById.set(session.id, session);
-  }
-
-  return {
-    allowedSessionIds: new Set(allSessions.map((session) => session.id)),
-    sessionById,
-    messagesBySession: new Map<string, MessageMeta[]>(),
-    partsBySession: new Map<string, PartMeta[]>(),
-    childrenBySession: new Map<string, SessionMetadata[]>(),
-  };
-}
-
-function getSessionFromContext(sessionId: string, context: SessionContext): SessionMetadata | undefined {
-  return context.sessionById.get(sessionId);
-}
-
-function getSessionMessages(sessionId: string, context: SessionContext): MessageMeta[] {
-  const cached = context.messagesBySession.get(sessionId);
-  if (cached) {
-    return cached;
-  }
-
-  const messages = queryMessages(sessionId, MAX_MESSAGE_QUERY_LIMIT).map(parseMessageRow);
-  context.messagesBySession.set(sessionId, messages);
-  return messages;
-}
-
-function getSessionParts(sessionId: string, context: SessionContext): PartMeta[] {
-  const cached = context.partsBySession.get(sessionId);
-  if (cached) {
-    return cached;
-  }
-
-  const parts = queryParts(sessionId).map(parsePartRow);
-  context.partsBySession.set(sessionId, parts);
-  return parts;
-}
-
-function getSessionChildren(sessionId: string, context: SessionContext): SessionMetadata[] {
-  const cached = context.childrenBySession.get(sessionId);
-  if (cached) {
-    return cached;
-  }
-
-  const children = querySessionChildren(sessionId)
-    .map(parseSessionRow)
-    .filter((child) => context.allowedSessionIds.has(child.id));
-
-  for (const child of children) {
-    if (!context.sessionById.has(child.id)) {
-      context.sessionById.set(child.id, child);
-    }
-  }
-
-  context.childrenBySession.set(sessionId, children);
-  return children;
-}
-
 
 function countBlockingChildren(statuses: SessionStatus[]): number {
   return statuses.filter((status) => status === "working" || status === "waiting").length;
@@ -148,108 +71,14 @@ function buildToolCalls(parts: PartMeta[], messageAgent: Map<string, string>): T
   return toolCalls.slice(0, 50);
 }
 
-export function buildAgentHierarchy(messages: MessageMeta[]): Record<string, string[]> {
-  const hierarchy: Record<string, string[]> = {};
-
-  for (const msg of messages) {
-    if (msg.agent && msg.parentID) {
-      const parentMsg = messages.find((m) => m.id === msg.parentID);
-      if (parentMsg?.agent) {
-        if (!hierarchy[parentMsg.agent]) {
-          hierarchy[parentMsg.agent] = [];
-        }
-        if (!hierarchy[parentMsg.agent].includes(msg.agent)) {
-          hierarchy[parentMsg.agent].push(msg.agent);
-        }
-      }
-    }
-  }
-
-  return hierarchy;
-}
-
-export async function buildSessionTree(
-  rootSessionID: string,
-  allSessions: SessionMetadata[]
-): Promise<SessionTree> {
-  const nodes: TreeNode[] = [];
-  const edges: TreeEdge[] = [];
-  const visited = new Set<string>();
-  const context = createSessionContext(allSessions);
-
-  async function processSession(sessionID: string, depth = 0) {
-    if (depth > MAX_RECURSION_DEPTH) {
-      console.warn(`Max recursion depth reached for session ${sessionID}`);
-      return;
-    }
-    if (visited.has(sessionID)) {
-      return;
-    }
-    visited.add(sessionID);
-
-    const session = getSessionFromContext(sessionID, context);
-    if (!session) {
-      return;
-    }
-
-    const messages = getSessionMessages(sessionID, context);
-    const lastAssistantFinished = isAssistantFinished(messages);
-    const isSubagent = !!session.parentID;
-    const status = getSessionStatusInfo(
-      messages,
-      false,
-      undefined,
-      undefined,
-      lastAssistantFinished,
-      isSubagent
-    ).status;
-
-    const lastMessage = messages.sort(
-      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-    )[0];
-
-    nodes.push({
-      id: session.id,
-      data: {
-        title: session.title,
-        agent: lastMessage?.agent,
-        model: lastMessage?.modelID,
-        isActive: status === "working" || status === "idle",
-      },
-    });
-
-    if (session.parentID) {
-      edges.push({
-        source: session.parentID,
-        target: session.id,
-      });
-      await processSession(session.parentID, depth + 1);
-    }
-
-    const children = getSessionChildren(sessionID, context);
-    await Promise.all(
-      children.map((child) => {
-        edges.push({
-          source: sessionID,
-          target: child.id,
-        });
-        return processSession(child.id, depth + 1);
-      })
-    );
-  }
-
-  await processSession(rootSessionID, 0);
-
-  return { nodes, edges };
-}
-
 export async function getSessionHierarchy(
   rootSessionId: string,
-  allSessions: SessionMetadata[]
+  allSessions: SessionMetadata[],
+  contextArg?: SessionContext,
 ): Promise<ActivitySession[]> {
   const result: ActivitySession[] = [];
   const processed = new Set<string>();
-  const context = createSessionContext(allSessions);
+  const context = contextArg ?? createSessionContext(allSessions);
 
   const rootSession = getSessionFromContext(rootSessionId, context);
   if (!rootSession) return result;
@@ -320,6 +149,7 @@ export async function getSessionHierarchy(
       id: rootSession.id,
       title: rootSession.title,
       agent: latestAssistantMsg?.agent || "unknown",
+      nodeKind: "session",
       modelID: latestAssistantMsg?.modelID,
       providerID: latestAssistantMsg?.providerID,
       parentID: rootSession.parentID,
@@ -419,6 +249,7 @@ export async function getSessionHierarchy(
         id: virtualId,
         title: rootSession.title,
         agent: phase.agent,
+        nodeKind: "phase",
         modelID: latestPhaseMsg?.modelID,
         providerID: latestPhaseMsg?.providerID,
         parentID: undefined,
@@ -442,7 +273,7 @@ export async function getSessionHierarchy(
   return result;
 }
 
-export async function processChildSession(
+async function processChildSession(
   sessionId: string,
   parentId: string,
   allSessions: SessionMetadata[],
@@ -526,6 +357,7 @@ export async function processChildSession(
     id: session.id,
     title: session.title,
     agent: latestAssistantMsg?.agent || "unknown",
+    nodeKind: "session",
     modelID: latestAssistantMsg?.modelID,
     providerID: latestAssistantMsg?.providerID,
     parentID: parentId,