ocwatch 0.5.0 → 0.6.0

package/src/server/services/sessionTree.ts

@@ -0,0 +1,92 @@
+import type {
+  SessionMetadata,
+  TreeNode,
+  TreeEdge,
+  SessionTree,
+} from "../../shared/types";
+import { MAX_RECURSION_DEPTH } from "../../shared/constants";
+import {
+  isAssistantFinished,
+  getSessionStatusInfo,
+} from "../logic";
+import {
+  createSessionContext,
+  getSessionFromContext,
+  getSessionMessages,
+  getSessionChildren,
+} from "./sessionContext";
+
+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 };
+}

package/src/server/storage/db.ts

@@ -22,15 +22,8 @@ function getDbPath(): string {
 }
 
 function configureConnectionPragmas(db: Database): void {
-  db.query("PRAGMA busy_timeout = 5000;").run();
-  db.query("PRAGMA cache_size = -20000;").run();
-
-  try {
-    db.query("PRAGMA journal_mode = WAL;").run();
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    console.warn(`[storage/db] Failed to enforce WAL journal mode: ${reason}`);
-  }
+  db.query(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS};`).run();
+  db.query(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE};`).run();
 }
 
 export function checkDbExists(): boolean {
@@ -68,4 +61,3 @@ export function closeDb(): void {
   dbSingleton.close();
   dbSingleton = undefined;
 }
-

package/src/server/storage/index.ts

@@ -2,20 +2,26 @@ export { checkDbExists, closeDb, getDb } from "./db";
 export {
   queryMaxTimestamp,
   queryMessages,
+  queryMessagesForSessions,
   queryPart,
   queryParts,
+  queryPartsForSessions,
   queryProjects,
+  queryProjectByWorktree,
+  queryProjectSummaries,
   querySession,
   querySessionChildren,
+  querySessionSubtree,
+  querySessionSubtreeRevision,
   querySessions,
   queryTodos,
   listProjects,
-  listAllSessions,
 } from "./queries";
 export type {
   DbMessageRow,
   DbPartRow,
   DbProjectRow,
+  DbProjectSummaryRow,
   DbSessionRow,
   DbTodoRow,
 } from "./queries";

package/src/server/storage/queries.ts

@@ -1,7 +1,5 @@
 import type { Database, Statement } from "bun:sqlite";
 import { getDb } from "./db";
-import type { SessionMetadata } from "../../shared/types";
-import { toSessionMetadata } from "../services/parsing";
 
 export interface DbProjectRow {
   id: string;
@@ -58,17 +56,28 @@ export interface DbTodoRow {
   timeUpdated: number;
 }
 
+export interface DbProjectSummaryRow {
+  id: string;
+  worktree: string;
+  sessionCount: number;
+  lastActivityAt: number;
+}
+
 let cachedDb: Database | null | undefined;
 
 let queryProjectsStmt: Statement<DbProjectRow, []> | null = null;
 let querySessionsStmt: Statement<DbSessionRow, [string | null, number | null, number]> | null = null;
 let querySessionStmt: Statement<DbSessionRow, [string]> | null = null;
 let querySessionChildrenStmt: Statement<DbSessionRow, [string]> | null = null;
+let querySessionSubtreeStmt: Statement<DbSessionRow, [string]> | null = null;
 let queryMessagesStmt: Statement<DbMessageRow, [string, number]> | null = null;
 let queryPartsStmt: Statement<DbPartRow, [string]> | null = null;
 let queryPartStmt: Statement<DbPartRow, [string]> | null = null;
 let queryTodosStmt: Statement<DbTodoRow, [string]> | null = null;
 let queryMaxTimestampStmt: Statement<{ maxTimestamp: number | null }, []> | null = null;
+let querySessionSubtreeRevisionStmt: Statement<{ maxTimestamp: number | null }, [string]> | null = null;
+let queryProjectByWorktreeStmt: Statement<DbProjectRow, [string]> | null = null;
+let queryProjectSummariesStmt: Statement<DbProjectSummaryRow, []> | null = null;
 
 function getReadyDb(): Database | null {
   const db = getDb();
@@ -145,6 +154,50 @@ function getReadyDb(): Database | null {
     ORDER BY time_created ASC
   `);
 
+  querySessionSubtreeStmt = db.query<DbSessionRow, [string]>(`
+    WITH RECURSIVE subtree AS (
+      SELECT
+        id,
+        project_id AS projectID,
+        parent_id AS parentID,
+        slug,
+        directory,
+        title,
+        version,
+        time_created AS timeCreated,
+        time_updated AS timeUpdated
+      FROM session
+      WHERE id = ?1
+
+      UNION ALL
+
+      SELECT
+        s.id,
+        s.project_id AS projectID,
+        s.parent_id AS parentID,
+        s.slug,
+        s.directory,
+        s.title,
+        s.version,
+        s.time_created AS timeCreated,
+        s.time_updated AS timeUpdated
+      FROM session s
+      INNER JOIN subtree st ON s.parent_id = st.id
+    )
+    SELECT
+      id,
+      projectID,
+      parentID,
+      slug,
+      directory,
+      title,
+      version,
+      timeCreated,
+      timeUpdated
+    FROM subtree
+    ORDER BY timeCreated ASC, id ASC
+  `);
+
   queryMessagesStmt = db.query<DbMessageRow, [string, number]>(`
     SELECT
       id,
@@ -225,6 +278,55 @@ function getReadyDb(): Database | null {
     )
   `);
 
+  querySessionSubtreeRevisionStmt = db.query<{ maxTimestamp: number | null }, [string]>(`
+    WITH RECURSIVE subtree AS (
+      SELECT id
+      FROM session
+      WHERE id = ?1
+
+      UNION ALL
+
+      SELECT s.id
+      FROM session s
+      INNER JOIN subtree st ON s.parent_id = st.id
+    )
+    SELECT MAX(ts) AS maxTimestamp
+    FROM (
+      SELECT MAX(time_updated) AS ts FROM session WHERE id IN (SELECT id FROM subtree)
+      UNION ALL
+      SELECT MAX(time_updated) AS ts FROM message WHERE session_id IN (SELECT id FROM subtree)
+      UNION ALL
+      SELECT MAX(time_updated) AS ts FROM part WHERE session_id IN (SELECT id FROM subtree)
+    )
+  `);
+
+  queryProjectByWorktreeStmt = db.query<DbProjectRow, [string]>(`
+    SELECT
+      id,
+      name,
+      worktree,
+      vcs,
+      commands,
+      sandboxes,
+      time_created AS timeCreated,
+      time_updated AS timeUpdated
+    FROM project
+    WHERE worktree = ?1
+    LIMIT 1
+  `);
+
+  queryProjectSummariesStmt = db.query<DbProjectSummaryRow, []>(`
+    SELECT
+      p.id,
+      p.worktree,
+      COUNT(s.id) AS sessionCount,
+      COALESCE(MAX(s.time_updated), p.time_updated) AS lastActivityAt
+    FROM project p
+    LEFT JOIN session s ON s.project_id = p.id
+    GROUP BY p.id
+    ORDER BY lastActivityAt DESC
+  `);
+
   return db;
 }
 
@@ -268,6 +370,15 @@ export function querySessionChildren(sessionId: string): DbSessionRow[] {
   return querySessionChildrenStmt.all(sessionId);
 }
 
+export function querySessionSubtree(sessionId: string): DbSessionRow[] {
+  const db = getReadyDb();
+  if (!db || !querySessionSubtreeStmt) {
+    return [];
+  }
+
+  return querySessionSubtreeStmt.all(sessionId);
+}
+
 export function queryMessages(sessionId: string, limit = 100): DbMessageRow[] {
   const db = getReadyDb();
   if (!db || !queryMessagesStmt) {
@@ -286,6 +397,76 @@ export function queryParts(sessionId: string): DbPartRow[] {
   return queryPartsStmt.all(sessionId);
 }
 
+export function queryMessagesForSessions(sessionIds: string[], limitPerSession = 100): DbMessageRow[] {
+  const db = getReadyDb();
+  if (!db || sessionIds.length === 0) {
+    return [];
+  }
+
+  const placeholders = sessionIds.map((_, index) => `?${index + 1}`).join(", ");
+  const limitParam = `?${sessionIds.length + 1}`;
+  const statement = db.query<DbMessageRow, (string | number)[]>(`
+    SELECT
+      id,
+      sessionID,
+      timeCreated,
+      timeUpdated,
+      role,
+      agent,
+      data
+    FROM (
+      SELECT
+        id,
+        session_id AS sessionID,
+        time_created AS timeCreated,
+        time_updated AS timeUpdated,
+        json_extract(data, '$.role') AS role,
+        json_extract(data, '$.agent') AS agent,
+        data,
+        ROW_NUMBER() OVER (
+          PARTITION BY session_id
+          ORDER BY time_created DESC, id DESC
+        ) AS rowNumber
+      FROM message
+      WHERE session_id IN (${placeholders})
+    )
+    WHERE rowNumber <= ${limitParam}
+    ORDER BY sessionID ASC, timeCreated DESC, id DESC
+  `);
+
+  return statement.all(...sessionIds, limitPerSession);
+}
+
+export function queryPartsForSessions(sessionIds: string[]): DbPartRow[] {
+  const db = getReadyDb();
+  if (!db || sessionIds.length === 0) {
+    return [];
+  }
+
+  const placeholders = sessionIds.map((_, index) => `?${index + 1}`).join(", ");
+  const statement = db.query<DbPartRow, string[]>(`
+    SELECT
+      id,
+      message_id AS messageID,
+      session_id AS sessionID,
+      time_created AS timeCreated,
+      time_updated AS timeUpdated,
+      json_extract(data, '$.type') AS type,
+      json_extract(data, '$.tool') AS tool,
+      CASE
+        WHEN json_type(data, '$.state') = 'text' THEN json_extract(data, '$.state')
+        WHEN json_type(data, '$.state.type') = 'text' THEN json_extract(data, '$.state.type')
+        ELSE NULL
+      END AS state,
+      data
+    FROM part
+    WHERE session_id IN (${placeholders})
+    ORDER BY sessionID ASC, timeCreated DESC, id DESC
+  `);
+
+  return statement.all(...sessionIds);
+}
+
 export function queryPart(partId: string): DbPartRow | null {
   const db = getReadyDb();
   if (!db || !queryPartStmt) {
@@ -313,13 +494,35 @@ export function queryMaxTimestamp(): number {
   return Number(queryMaxTimestampStmt.get()?.maxTimestamp ?? 0);
 }
 
+export function querySessionSubtreeRevision(sessionId: string): number {
+  const db = getReadyDb();
+  if (!db || !querySessionSubtreeRevisionStmt) {
+    return 0;
+  }
+
+  return Number(querySessionSubtreeRevisionStmt.get(sessionId)?.maxTimestamp ?? 0);
+}
+
 
 export function listProjects(): string[] {
   const projects = queryProjects();
   return projects.map((p) => p.id);
 }
 
-export function listAllSessions(): SessionMetadata[] {
-  const sessions = querySessions(undefined, undefined, 10000);
-  return sessions.map(toSessionMetadata);
+export function queryProjectByWorktree(directory: string): DbProjectRow | null {
+  const db = getReadyDb();
+  if (!db || !queryProjectByWorktreeStmt) {
+    return null;
+  }
+
+  return queryProjectByWorktreeStmt.get(directory);
+}
+
+export function queryProjectSummaries(): DbProjectSummaryRow[] {
+  const db = getReadyDb();
+  if (!db || !queryProjectSummariesStmt) {
+    return [];
+  }
+
+  return queryProjectSummariesStmt.all();
 }

package/src/server/utils/projectResolver.ts

@@ -1,5 +1,5 @@
 import { stat } from "node:fs/promises";
-import { listAllSessions } from "../storage";
+import { queryProjects } from "../storage";
 import type { SessionMetadata } from "../../shared/types";
 
 async function directoryExists(directory: string): Promise<boolean> {
@@ -15,8 +15,14 @@ export async function resolveProjectDirectory(
   projectId: string,
   preloadedSessions?: SessionMetadata[],
 ): Promise<string | null> {
-  const allSessions = preloadedSessions ?? listAllSessions();
-  const directory = allSessions.find((session) => session.projectID === projectId)?.directory;
+  let directory: string | undefined;
+
+  if (preloadedSessions) {
+    directory = preloadedSessions.find((session) => session.projectID === projectId)?.directory;
+  } else {
+    const projects = queryProjects();
+    directory = projects.find((p) => p.id === projectId)?.worktree;
+  }
 
   if (!directory) {
     return null;

package/src/server/utils/sessionStatus.ts

@@ -3,7 +3,7 @@
  * Determines session status based on message timestamps and tool call state
  */
 
-import type { MessageMeta, SessionStatus } from "../../shared/types";
+import type { SessionStatus } from "../../shared/types";
 import { isPendingToolCall } from "../logic/activityLogic";
 import { getSessionStatusInfo } from "../logic/sessionLogic";
 
@@ -14,24 +14,6 @@ export type { WaitingReason, SessionStatusInfo } from "../logic/sessionLogic";
 // Thresholds in milliseconds
 const WORKING_THRESHOLD = 30 * 1000; // 30 seconds
 const COMPLETED_THRESHOLD = 5 * 60 * 1000; // 5 minutes
-export function getSessionStatus(
-  messages: MessageMeta[],
-  hasPendingToolCall: boolean = false,
-  lastToolCompletedAt?: Date,
-  workingChildCount?: number,
-  lastAssistantFinished?: boolean,
-  isSubagent: boolean = false
-): SessionStatus {
-  return getSessionStatusInfo(
-    messages,
-    hasPendingToolCall,
-    lastToolCompletedAt,
-    workingChildCount,
-    lastAssistantFinished,
-    isSubagent
-  ).status;
-}
-
 /**
  * Get status from timestamp directly (for simpler cases)
  * Used when you only have the updatedAt timestamp

package/src/server/validation.ts

@@ -5,14 +5,12 @@ export const sessionIdSchema = z.string().regex(/^ses_[a-zA-Z0-9]+$/, 'Invalid s
 
 export const partIdSchema = z.string().min(1, 'Part ID required');
 
+export const projectIdSchema = z.string().regex(/^[a-zA-Z0-9_-]+$/, 'Invalid project ID format');
+
 export const pollQuerySchema = z.object({
   sessionId: sessionIdSchema.optional(),
 });
 
-export function validateParam<T>(schema: z.ZodSchema<T>, value: unknown): T {
-  return schema.parse(value);
-}
-
 export type ValidationResult<T> = { success: true; value: T } | { success: false; response: Response };
 
 export function validateWithResponse<T>(

package/src/server/watcher.ts

@@ -1,4 +1,4 @@
-import { existsSync, watch, type FSWatcher } from "node:fs";
+import { existsSync, statSync, watch, type FSWatcher } from "node:fs";
 import { basename, join } from "node:path";
 import { EventEmitter } from "node:events";
 import { homedir } from "node:os";
@@ -23,6 +23,7 @@ export class Watcher extends EventEmitter {
   private readonly projectPath: string;
   private dbWatcherTarget: string | null = null;
   private boulderWatcherTarget: string | null = null;
+  private lastKnownBoulderSignature: string | null = null;
   private isRunning: boolean = false;
 
   constructor(options: WatcherOptions = {}) {
@@ -144,15 +145,24 @@ export class Watcher extends EventEmitter {
       this.handleBoulderEvent(eventType, filename);
     });
     this.boulderWatcherTarget = preferredTarget;
+    this.lastKnownBoulderSignature = this.getBoulderSignature();
   }
 
   private handleBoulderEvent(eventType: string, filename: string | null): void {
+    const currentSignature = this.getBoulderSignature();
+    const signatureChanged = currentSignature !== this.lastKnownBoulderSignature;
+
     if (this.boulderWatcherTarget === this.boulderDirPath) {
-      if (!filename || filename !== "boulder.json") {
+      if (filename && filename !== "boulder.json" && !signatureChanged) {
+        return;
+      }
+
+      if (!filename && !signatureChanged) {
         return;
       }
     }
 
+    this.lastKnownBoulderSignature = currentSignature;
     this.emitDebouncedChange(eventType, ".sisyphus/boulder.json");
 
     if (eventType === "rename") {
@@ -168,6 +178,32 @@ export class Watcher extends EventEmitter {
     }
   }
 
+  private getBoulderSignature(): string | null {
+    try {
+      const stats = statSync(this.boulderPath);
+      return `${stats.size}:${stats.mtimeMs}`;
+    } catch {
+      return null;
+    }
+  }
+
+  private pollForBoulderChanges(): void {
+    const currentSignature = this.getBoulderSignature();
+    if (currentSignature === this.lastKnownBoulderSignature) {
+      return;
+    }
+
+    this.lastKnownBoulderSignature = currentSignature;
+    this.emitDebouncedChange("change", ".sisyphus/boulder.json");
+
+    const preferredTarget = existsSync(this.boulderPath)
+      ? this.boulderPath
+      : this.boulderDirPath;
+    if (preferredTarget !== this.boulderWatcherTarget) {
+      this.rebindBoulderWatcherSafe();
+    }
+  }
+
   private startRebindLoop(): void {
     if (this.rebindTimer) {
       clearInterval(this.rebindTimer);
@@ -178,9 +214,10 @@ export class Watcher extends EventEmitter {
         return;
       }
 
+      this.pollForBoulderChanges();
       this.rebindDbWatcherSafe();
       this.rebindBoulderWatcherSafe();
-    }, 1000);
+    }, 100);
   }
 
   private rebindDbWatcherSafe(): void {
@@ -226,6 +263,7 @@ export class Watcher extends EventEmitter {
       this.boulderWatcherTarget = null;
     }
 
+    this.lastKnownBoulderSignature = null;
     this.isRunning = false;
     this.emit("stopped");
   }

package/src/shared/constants.ts

@@ -5,9 +5,6 @@
 export const DEFAULT_PORT = 50234 as const;
 export const API_BASE_URL = `http://localhost:${DEFAULT_PORT}`;
 
-// Time constants
-export const TWENTY_FOUR_HOURS_MS = 86400000 as const;
-
 // API limits
 export const MAX_SESSIONS_LIMIT = 20 as const;
 /** Messages returned per session in API responses (client-facing limit) */
@@ -21,3 +18,10 @@ export const RINGBUFFER_CAPACITY = 1000 as const;
 
 // Session hierarchy depth limit
 export const MAX_RECURSION_DEPTH = 10 as const;
+
+/** Internal upper bound for session queries (not client-facing) */
+export const SESSION_SCAN_LIMIT = 50_000 as const;
+/** Internal upper bound for message queries per session (not client-facing) */
+export const MESSAGE_SCAN_LIMIT = 10_000 as const;
+/** Cooldown between notifications for the same session (ms) */
+export const NOTIFICATION_COOLDOWN_MS = 10_000 as const;

package/src/shared/index.ts

@@ -1,2 +1,5 @@
 export const VERSION = "0.1.0";
 export const PROJECT_NAME = "OCWatch";
+
+export { synthesizeActivityItems } from './utils/activityUtils';
+export { RingBuffer } from './utils/RingBuffer';

package/src/shared/types/index.ts

@@ -74,11 +74,13 @@ export interface MessageMeta {
  * Includes agent info and hierarchy
  */
 export type SessionActivityType = "tool" | "reasoning" | "patch" | "waiting-tools" | "waiting-user" | "idle";
+export type ActivityNodeKind = "session" | "phase";
 
 export interface ActivitySession {
   id: string;
   title: string;
   agent: string;
+  nodeKind?: ActivityNodeKind;
   modelID?: string;
   providerID?: string;
   parentID?: string;
@@ -126,17 +128,6 @@ export interface PartMeta {
   patchFiles?: string[];
 }
 
-/**
- * AgentInfo represents an active agent
- */
-export interface AgentInfo {
-  name: string;
-  mode: string;
-  modelID: string;
-  active: boolean;
-  sessionID: string;
-}
-
 /**
  * ToolCall represents a tool invocation
  */
@@ -214,41 +205,6 @@ export type ActivityItem =
   | AgentSpawnActivity
   | AgentCompleteActivity;
 
-/**
- * BurstEntry represents a burst of tool call activity
- * Groups consecutive tool calls from the same agent with aggregated metrics
- */
-export interface BurstEntry {
-  id: string;
-  type: "burst";
-  agentName: string;
-  items: ToolCallActivity[];
-  toolBreakdown: Record<string, number>;
-  durationMs: number;
-  firstTimestamp: Date;
-  lastTimestamp: Date;
-  pendingCount: number;
-  errorCount: number;
-}
-
-/**
- * MilestoneEntry represents a significant event in the activity stream
- * (agent spawn or agent complete)
- */
-export interface MilestoneEntry {
-  id: string;
-  type: "milestone";
-  item: AgentSpawnActivity | AgentCompleteActivity;
-}
-
-/**
- * StreamEntry is a union type for activity stream entries
- * Represents either a burst of tool calls or a milestone event
- */
-export type StreamEntry = BurstEntry | MilestoneEntry;
-
-export { synthesizeActivityItems } from '../utils/activityUtils';
-
 /**
  * PlanProgress represents progress on a plan
  */
@@ -284,6 +240,13 @@ export interface SessionStats {
   modelBreakdown: ModelTokens[];
 }
 
+export interface SessionActivityResponse {
+  session: SessionSummary;
+  activity: ActivitySession[];
+  stats: SessionStats | null;
+  revision: number;
+}
+
 /**
  * Boulder represents the current plan state
  */
@@ -359,5 +322,3 @@ export interface PollResponse {
   planName?: string;
   lastUpdate: number;
 }
-
-export { RingBuffer } from '../utils/RingBuffer';