Handoff merged master work and UI refinements

.env.example

@@ -13,3 +13,10 @@ OMO_PULSE_API_PORT=4301
 # Set to "true" in CI/CD environments to prevent Playwright from reusing existing servers
 # In local development, leave unset (defaults to false)
 CI=
+
+# Telegram Notifications (optional)
+# Get token from @BotFather, chat ID from @userinfobot or the getUpdates API
+# When both are set, omo-pulse pushes a pinned status message to the chat
+# and sends alert notifications for question/error/plan_complete transitions.
+TELEGRAM_BOT_TOKEN=
+TELEGRAM_CHAT_ID=

README.md

@@ -6,6 +6,7 @@
 [![Runtime: Bun](https://img.shields.io/badge/Runtime-Bun-%23f9f1e1?logo=bun)](https://bun.sh)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.5-blue?logo=typescript)](https://www.typescriptlang.org/)
 [![Sponsor](https://img.shields.io/badge/sponsor-%E2%9D%A4-lightgrey)](https://github.com/sponsors/EZotoff)
+[![Ko-fi](https://img.shields.io/badge/Ko--fi-Support-ff5e5b?logo=ko-fi&logoColor=white)](https://ko-fi.com/ezotoff)
 
 ![Dashboard — multi-project view with session activity and token usage](docs/screenshots/details-collapsed.png)
 

src/__tests__/api.test.ts

@@ -22,16 +22,6 @@ vi.mock("../ingest/sources-registry", () => ({
   getSourceById: vi.fn(() => null),
 }))
 
-vi.mock("../server/multi-project", () => ({
-  createMultiProjectService: vi.fn(() => ({
-    getMultiProjectPayload: vi.fn(async (): Promise<DashboardMultiProjectPayload> => ({
-      projects: [],
-      serverNowMs: Date.now(),
-      pollIntervalMs: 2000,
-    })),
-  })),
-}))
-
 vi.mock("../ingest/session", () => ({
   getStorageRoots: vi.fn(() => ({
     session: "/tmp/session",
@@ -63,7 +53,6 @@ vi.mock("../ingest/sqlite-derive", () => ({
 // Import AFTER mocking
 // ---------------------------------------------------------------------------
 import { createApi } from "../server/api"
-import { createMultiProjectService } from "../server/multi-project"
 import type { ProjectSnapshot } from "../types"
 
 // ---------------------------------------------------------------------------
@@ -83,6 +72,8 @@ function makeProjectSnapshot(overrides: Partial<ProjectSnapshot> = {}): ProjectS
       sessionId: "ses_abc",
       status: "idle",
     },
+    sessions: [],
+    aggregateStatus: "idle",
     planProgress: {
       name: "plan-1",
       completed: 3,
@@ -93,6 +84,7 @@ function makeProjectSnapshot(overrides: Partial<ProjectSnapshot> = {}): ProjectS
       planStale: false,
       planComplete: false,
     },
+    unintiatedPlans: [],
     timeSeries: {
       windowMs: 300000,
       bucketMs: 2000,
@@ -127,12 +119,13 @@ describe("API routes", () => {
         serverNowMs: Date.now(),
         pollIntervalMs: 2000,
       })),
+      invalidate: vi.fn(),
     }
-    vi.mocked(createMultiProjectService).mockReturnValue(mockService)
 
     app = createApi({
       storageRoot: "/tmp/test-storage",
       storageBackend: { kind: "sqlite", dataDir: "/tmp", sqlitePath: "/tmp/test.db" },
+      multiProjectService: mockService,
       version: "1.0.0-test",
     })
   })

src/__tests__/question-bridge.test.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs"
 import * as os from "node:os"
 import * as path from "node:path"
 
-import { afterEach, describe, expect, it } from "vitest"
+import { afterEach, describe, expect, it, vi } from "vitest"
 
 import { deriveBackgroundTasks } from "../ingest/background-tasks"
 import { getMainSessionView, type OpenCodeStorageRoots, type SessionMetadata, type StoredMessageMeta, type StoredToolPart } from "../ingest/session"
@@ -32,6 +32,8 @@ function makeTempStorage(): OpenCodeStorageRoots {
 }
 
 afterEach(() => {
+  vi.resetModules()
+  vi.doUnmock("../ingest/storage-backend")
   while (tempDirs.length > 0) {
     const dir = tempDirs.pop()
     if (dir) fs.rmSync(dir, { recursive: true, force: true })
@@ -163,4 +165,115 @@ describe("background question bridge", () => {
     expect(view.status).toBe("question")
     expect(view.currentTool).toBe("mcp_question")
   })
+
+  it("surfaces question for SQLite background tasks and main-session fallback", async () => {
+    vi.doMock("../ingest/storage-backend", () => {
+      const mainSessionMeta: SessionMetadata = {
+        id: "ses-main",
+        projectID: "proj-1",
+        directory: "/tmp/project",
+        time: { created: 900_000, updated: 999_000 },
+      }
+      const childSessionMeta: SessionMetadata = {
+        id: "ses-child",
+        projectID: "proj-1",
+        directory: "/tmp/project",
+        parentID: "ses-main",
+        title: "Ask the user (@atlas subagent)",
+        time: { created: 999_100, updated: 999_900 },
+      }
+      const mainMeta: StoredMessageMeta = {
+        id: "msg-main",
+        sessionID: "ses-main",
+        role: "assistant",
+        time: { created: 999_000, completed: 999_100 },
+        agent: "build",
+      }
+      const childMeta: StoredMessageMeta = {
+        id: "msg-child",
+        sessionID: "ses-child",
+        role: "assistant",
+        time: { created: 999_900 },
+        agent: "atlas",
+      }
+      const mainTaskPart: PersistedToolPart = {
+        id: "part-main",
+        sessionID: "ses-main",
+        messageID: "msg-main",
+        type: "tool",
+        callID: "call-main",
+        tool: "background_task",
+        state: {
+          status: "completed",
+          input: {
+            description: "Ask the user",
+            run_in_background: true,
+            subagent_type: "atlas",
+          },
+          metadata: { sessionId: "ses-child" },
+          time: { start: 999_050 },
+        },
+      }
+      const childQuestionPart: StoredToolPart = {
+        id: "part-child",
+        sessionID: "ses-child",
+        messageID: "msg-child",
+        type: "tool",
+        callID: "call-child",
+        tool: "mcp_question",
+        state: {
+          status: "pending",
+          input: {},
+        },
+      }
+
+      return {
+        readMainSessionMetasSqlite: vi.fn(() => ({ ok: true as const, rows: [mainSessionMeta] })),
+        readAllSessionMetasSqlite: vi.fn(() => ({ ok: true as const, rows: [mainSessionMeta, childSessionMeta] })),
+        readSessionExistsSqlite: vi.fn(() => ({ ok: true as const, rows: [{ id: "ses-child" }] })),
+        readTodosSqlite: vi.fn(() => ({ ok: true as const, rows: [] })),
+        readRecentMessageMetasSqlite: vi.fn(({ sessionId }: { sessionId: string }) => {
+          if (sessionId === "ses-main") return { ok: true as const, rows: [mainMeta] }
+          if (sessionId === "ses-child") return { ok: true as const, rows: [childMeta] }
+          return { ok: true as const, rows: [] }
+        }),
+        readToolPartsForMessagesSqlite: vi.fn(({ messageIds }: { messageIds: string[] }) => {
+          const rows: StoredToolPart[] = []
+          if (messageIds.includes("msg-main")) rows.push(mainTaskPart)
+          if (messageIds.includes("msg-child")) rows.push(childQuestionPart)
+          return { ok: true as const, rows }
+        }),
+      }
+    })
+
+    const { deriveBackgroundTasksSqlite, getMainSessionViewSqlite } = await import("../ingest/sqlite-derive")
+
+    const tasksResult = deriveBackgroundTasksSqlite({
+      sqlitePath: "/tmp/opencode.db",
+      mainSessionId: "ses-main",
+      nowMs: 1_000_000,
+    })
+
+    expect(tasksResult.ok).toBe(true)
+    if (!tasksResult.ok) throw new Error("expected sqlite background tasks")
+    expect(tasksResult.value[0]?.status).toBe("question")
+    expect(tasksResult.value[0]?.lastTool).toBe("mcp_question")
+
+    const viewResult = getMainSessionViewSqlite({
+      sqlitePath: "/tmp/opencode.db",
+      sessionId: "ses-main",
+      sessionMeta: {
+        id: "ses-main",
+        projectID: "proj-1",
+        directory: "/tmp/project",
+        time: { created: 900_000, updated: 999_000 },
+      },
+      nowMs: 1_000_000,
+    })
+
+    expect(viewResult.ok).toBe(true)
+    if (!viewResult.ok) throw new Error("expected sqlite main session view")
+    expect(viewResult.value.status).toBe("question")
+    expect(viewResult.value.currentTool).toBe("mcp_question")
+  })
 })

src/__tests__/session-inclusion.test.ts

@@ -19,19 +19,19 @@ type SessionRow = {
 
 type ActivePartRow = {
   tool: string
-  status: string
+  status?: string
 }
 
-type ErrorCountRow = {
-  cnt: number
+type TerminalPartRow = {
+  status: string
+  time_created: number
 }
 
 type AssistantMessageRow = {
-  role: string
-  time_completed?: number
+  time_completed: number | null
 }
 
-type QueryRows = SessionRow[] | ActivePartRow[] | ErrorCountRow[] | AssistantMessageRow[]
+type QueryRows = SessionRow[] | ActivePartRow[] | TerminalPartRow[] | AssistantMessageRow[]
 
 type MockStatement = {
   all: (...params: unknown[]) => QueryRows
@@ -44,7 +44,7 @@ type MockDatabase = {
 type MockDbConfig = {
   sessionRows?: SessionRow[]
   activePartsBySession?: Record<string, ActivePartRow[]>
-  errorCountsBySession?: Record<string, number>
+  terminalPartsBySession?: Record<string, TerminalPartRow[]>
   assistantMessagesBySession?: Record<string, AssistantMessageRow[]>
   throwOnQuery?: boolean
 }
@@ -64,15 +64,15 @@ function createMockDb(config: MockDbConfig = {}): MockDatabase {
             return config.sessionRows ?? []
           }
 
-          if (sql.includes("state_status = 'pending' OR state_status = 'running'")) {
+          if (sql.includes("'pending', 'running'")) {
             return sessionId ? (config.activePartsBySession?.[sessionId] ?? []) : []
           }
 
-          if (sql.includes("state_status = 'error'")) {
-            return [{ cnt: sessionId ? (config.errorCountsBySession?.[sessionId] ?? 0) : 0 }]
+          if (sql.includes("'error', 'completed'")) {
+            return sessionId ? (config.terminalPartsBySession?.[sessionId] ?? []) : []
           }
 
-          if (sql.includes("FROM message")) {
+          if (sql.includes("json_extract(data, '$.role') = 'assistant'")) {
             return sessionId ? (config.assistantMessagesBySession?.[sessionId] ?? []) : []
           }
 
@@ -273,7 +273,7 @@ describe("findIncludedSessionsSqlite", () => {
     expect(result.map((session) => session.id)).toEqual(["stale-question"])
   })
 
-  it("keeps stale error sessions included beyond the normal idle window", () => {
+  it("excludes stale error sessions once error and activity are both stale", () => {
     const now = Date.now()
     const result = runFindIncludedSessionsSqlite(
       createMockDb({
@@ -293,15 +293,15 @@ describe("findIncludedSessionsSqlite", () => {
             time_updated: now - 120000,
           },
         ],
-        errorCountsBySession: {
-          "stale-error": 1,
+        terminalPartsBySession: {
+          "stale-error": [{ status: "error", time_created: now - 120000 }],
         },
       }),
       "/home/user/project",
       60000,
     )
 
-    expect(result.map((session) => session.id)).toEqual(["stale-error"])
+    expect(result.map((session) => session.id)).toEqual([])
   })
 
   it("does not treat generic mc_* tools as question status", () => {
@@ -511,8 +511,8 @@ describe("findIncludedSessionsSqlite", () => {
         activePartsBySession: {
           "question-session": [{ tool: "mcp_question", status: "pending" }],
         },
-        errorCountsBySession: {
-          "error-session": 1,
+        terminalPartsBySession: {
+          "error-session": [{ status: "error", time_created: now - 30000 }],
         },
       }),
       "/home/user/project",

src/ingest/activity-status.ts

@@ -2,6 +2,7 @@ import { TASK_TOOL_NAMES } from "./tool-names"
 
 export const ACTIVE_STALE_MS = 10 * 60_000
 export const ACTIVE_BUSY_WINDOW_MS = 60_000
+export const ERROR_STALE_MS = 60_000  // Errors become stale after 1 minute
 export const BACKGROUND_RUNNING_WINDOW_MS = 15_000
 export const BACKGROUND_QUEUE_STALE_MS = 15 * 60_000
 
@@ -22,3 +23,16 @@ export function resolveLastUpdatedTime(primary: number | null, fallback: number
 export function shouldSuppressStaleToolActivity(toolName: string, hasFreshActivity: boolean): boolean {
   return !hasFreshActivity && TASK_TOOL_NAMES.has(toolName)
 }
+
+export function getTerminalErrorMessageCreatedAt<T>(opts: {
+  orderedMessages: readonly T[]
+  getCreatedAt: (message: T) => number | null
+  hasErrorPart: (message: T) => boolean
+}): number | null {
+  for (const message of opts.orderedMessages) {
+    const createdAt = opts.getCreatedAt(message)
+    if (typeof createdAt !== "number") continue
+    return opts.hasErrorPart(message) ? createdAt : null
+  }
+  return null
+}