oh-my-opencode-dashboard 0.0.5 → 0.1.1

package/src/app-payload.test.ts

@@ -155,4 +155,111 @@ describe('toDashboardPayload', () => {
     // #then: should handle non-array steps gracefully
     expect(payload.planProgress.steps).toEqual([])
   })
-})
+
+  it('should parse mainSession.sessionId from camel or snake keys', () => {
+    // #given: server JSON with main session id in camel and snake case
+    const camelJson = {
+      mainSession: {
+        agent: "sisyphus",
+        currentTool: "dashboard_start",
+        currentModel: "anthropic/claude-opus-4-5",
+        lastUpdatedLabel: "just now",
+        session: "test-session",
+        sessionId: "ses_main",
+        statusPill: "busy",
+      },
+    }
+
+    const snakeJson = {
+      main_session: {
+        agent: "sisyphus",
+        current_tool: "dashboard_start",
+        current_model: "anthropic/claude-opus-4-5",
+        last_updated: "just now",
+        session: "test-session",
+        session_id: "ses_snake",
+        status: "busy",
+      },
+    }
+
+    // #when: converting to dashboard payload
+    const camelPayload = toDashboardPayload(camelJson)
+    const snakePayload = toDashboardPayload(snakeJson)
+
+    // #then: sessionId should be preserved
+    expect(camelPayload.mainSession.sessionId).toBe("ses_main")
+    expect(snakePayload.mainSession.sessionId).toBe("ses_snake")
+  })
+
+  it('should preserve mainSessionTasks from server JSON', () => {
+    // #given: server JSON with mainSessionTasks
+    const serverJson = {
+      mainSession: {
+        agent: "sisyphus",
+        currentTool: "dashboard_start",
+        currentModel: "anthropic/claude-opus-4-5",
+        lastUpdatedLabel: "just now",
+        session: "test-session",
+        sessionId: "ses_main",
+        statusPill: "busy",
+      },
+      planProgress: {
+        name: "test-plan",
+        completed: 0,
+        total: 0,
+        path: "/tmp/test-plan.md",
+        statusPill: "not started",
+        steps: [],
+      },
+      mainSessionTasks: [
+        {
+          id: "main-session",
+          description: "Main session",
+          subline: "ses_main",
+          agent: "sisyphus",
+          lastModel: "anthropic/claude-opus-4-5",
+          sessionId: "ses_main",
+          status: "running",
+          toolCalls: 3,
+          lastTool: "delegate_task",
+          timeline: "2026-01-01T00:00:00Z: 2m",
+        },
+      ],
+      backgroundTasks: [],
+      timeSeries: {
+        windowMs: 300000,
+        buckets: 150,
+        bucketMs: 2000,
+        anchorMs: 1640995200000,
+        serverNowMs: 1640995500000,
+        series: [
+          {
+            id: "overall-main",
+            label: "Overall",
+            tone: "muted",
+            values: new Array(150).fill(0),
+          },
+        ],
+      },
+    }
+
+    // #when
+    const payload = toDashboardPayload(serverJson)
+
+    // #then
+    expect(payload.mainSessionTasks).toEqual([
+      {
+        id: "main-session",
+        description: "Main session",
+        subline: "ses_main",
+        agent: "sisyphus",
+        lastModel: "anthropic/claude-opus-4-5",
+        sessionId: "ses_main",
+        status: "running",
+        toolCalls: 3,
+        lastTool: "delegate_task",
+        timeline: "2026-01-01T00:00:00Z: 2m",
+      },
+    ])
+  })
+})

package/src/server/api.test.ts

@@ -15,6 +15,10 @@ function mkStorageRoot(): string {
   return root
 }
 
+function mkProjectRoot(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "omo-dashboard-project-"))
+}
+
 function writeMessageMeta(opts: {
   storageRoot: string
   sessionId: string
@@ -75,9 +79,18 @@ function hasSensitiveKeys(value: unknown): boolean {
 
 const createStore = (): DashboardStore => ({
   getSnapshot: (): DashboardPayload => ({
-    mainSession: { agent: "x", currentModel: null, currentTool: "-", lastUpdatedLabel: "never", session: "s", statusPill: "idle" },
+    mainSession: {
+      agent: "x",
+      currentModel: null,
+      currentTool: "-",
+      lastUpdatedLabel: "never",
+      session: "s",
+      sessionId: null,
+      statusPill: "idle",
+    },
     planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started", steps: [] as PlanStep[] },
     backgroundTasks: [],
+    mainSessionTasks: [],
     timeSeries: {
       windowMs: 0,
       bucketMs: 0,
@@ -93,8 +106,9 @@ const createStore = (): DashboardStore => ({
 describe('API Routes', () => {
   it('should return health check', async () => {
     const storageRoot = mkStorageRoot()
+    const projectRoot = mkProjectRoot()
     const store = createStore()
-    const api = createApi({ store, storageRoot })
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/health")
     expect(res.status).toBe(200)
@@ -103,8 +117,9 @@ describe('API Routes', () => {
 
   it('should return dashboard data without sensitive keys', async () => {
     const storageRoot = mkStorageRoot()
+    const projectRoot = mkProjectRoot()
     const store = createStore()
-    const api = createApi({ store, storageRoot })
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/dashboard")
     expect(res.status).toBe(200)
@@ -122,8 +137,9 @@ describe('API Routes', () => {
 
   it('should reject invalid session IDs', async () => {
     const storageRoot = mkStorageRoot()
+    const projectRoot = mkProjectRoot()
     const store = createStore()
-    const api = createApi({ store, storageRoot })
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/tool-calls/not_valid!")
     expect(res.status).toBe(400)
@@ -132,8 +148,9 @@ describe('API Routes', () => {
 
   it('should return 404 for missing sessions', async () => {
     const storageRoot = mkStorageRoot()
+    const projectRoot = mkProjectRoot()
     const store = createStore()
-    const api = createApi({ store, storageRoot })
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/tool-calls/ses_missing")
     expect(res.status).toBe(404)
@@ -142,9 +159,10 @@ describe('API Routes', () => {
 
   it('should return empty tool calls for existing sessions', async () => {
     const storageRoot = mkStorageRoot()
+    const projectRoot = mkProjectRoot()
     writeMessageMeta({ storageRoot, sessionId: "ses_empty", messageId: "msg_1", created: 1000 })
     const store = createStore()
-    const api = createApi({ store, storageRoot })
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/tool-calls/ses_empty")
     expect(res.status).toBe(200)
@@ -160,6 +178,7 @@ describe('API Routes', () => {
 
   it('should redact tool call payload fields', async () => {
     const storageRoot = mkStorageRoot()
+    const projectRoot = mkProjectRoot()
     writeMessageMeta({ storageRoot, sessionId: "ses_redact", messageId: "msg_1", created: 1000 })
     writeToolPart({
       storageRoot,
@@ -175,7 +194,7 @@ describe('API Routes', () => {
       },
     })
     const store = createStore()
-    const api = createApi({ store, storageRoot })
+    const api = createApi({ store, storageRoot, projectRoot })
 
     const res = await api.request("/tool-calls/ses_redact")
     expect(res.status).toBe(200)
@@ -185,4 +204,6 @@ describe('API Routes', () => {
     expect(data.toolCalls.length).toBe(1)
     expect(hasSensitiveKeys(data)).toBe(false)
   })
+
+  // /sessions was intentionally removed along with the manual session picker.
 })

package/src/server/api.ts

@@ -6,7 +6,7 @@ import { deriveToolCalls, MAX_TOOL_CALL_MESSAGES, MAX_TOOL_CALLS } from "../inge
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/
 
-export function createApi(opts: { store: DashboardStore; storageRoot: string }): Hono {
+export function createApi(opts: { store: DashboardStore; storageRoot: string; projectRoot: string }): Hono {
   const api = new Hono()
 
   api.get("/health", (c) => {

package/src/server/dashboard.test.ts

@@ -76,9 +76,49 @@ describe("buildDashboardPayload", () => {
       expect(payload.mainSession.currentTool).toBe("delegate_task")
       expect(payload.mainSession.agent).toBe("sisyphus")
       expect(payload.mainSession.currentModel).toBeNull()
+      expect(payload.mainSession.sessionId).toBe(sessionId)
       
       expect(payload.raw).not.toHaveProperty("prompt")
       expect(payload.raw).not.toHaveProperty("input")
+
+      expect(payload).toHaveProperty("mainSessionTasks")
+      expect((payload as any).mainSessionTasks).toEqual([
+        {
+          id: "main-session",
+          description: "Main session",
+          subline: sessionId,
+          agent: "sisyphus",
+          lastModel: null,
+          status: "running",
+          toolCalls: 1,
+          lastTool: "delegate_task",
+          timeline: "1970-01-01T00:00:01Z: 1s",
+          sessionId,
+        },
+      ])
+
+      expect(payload.raw).toHaveProperty("mainSessionTasks.0.lastTool", "delegate_task")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
+
+  it("includes mainSessionTasks in raw payload when no sessions exist", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+
+    try {
+      const payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 2000,
+      })
+
+      expect(payload).toHaveProperty("mainSessionTasks")
+      expect((payload as any).mainSessionTasks).toEqual([])
+      expect(payload.raw).toHaveProperty("mainSessionTasks")
     } finally {
       fs.rmSync(storageRoot, { recursive: true, force: true })
       fs.rmSync(projectRoot, { recursive: true, force: true })
@@ -149,6 +189,7 @@ describe("buildDashboardPayload", () => {
       expect(payload).toHaveProperty("timeSeries")
       expect(payload.raw).toHaveProperty("timeSeries")
       expect(payload.mainSession.currentModel).toBeNull()
+      expect(payload.mainSession.sessionId).toBeNull()
 
       const sensitiveKeys = ["prompt", "input", "output", "error", "state"]
 

package/src/server/dashboard.ts

@@ -4,6 +4,7 @@ import { readBoulderState, readPlanProgress, readPlanSteps, type PlanStep } from
 import { deriveBackgroundTasks } from "../ingest/background-tasks"
 import { deriveTimeSeriesActivity, type TimeSeriesPayload } from "../ingest/timeseries"
 import { getMainSessionView, getStorageRoots, pickActiveSessionId, readMainSessionMetas, type MainSessionView, type OpenCodeStorageRoots, type SessionMetadata } from "../ingest/session"
+import { deriveToolCalls } from "../ingest/tool-calls"
 
 export type DashboardPayload = {
   mainSession: {
@@ -12,6 +13,7 @@ export type DashboardPayload = {
     currentTool: string
     lastUpdatedLabel: string
     session: string
+    sessionId: string | null
     statusPill: string
   }
   planProgress: {
@@ -33,6 +35,18 @@ export type DashboardPayload = {
     timeline: string
     sessionId: string | null
   }>
+  mainSessionTasks: Array<{
+    id: string
+    description: string
+    subline?: string
+    agent: string
+    lastModel: string | null
+    status: string
+    toolCalls: number
+    lastTool: string
+    timeline: string
+    sessionId: string | null
+  }>
   timeSeries: TimeSeriesPayload
   raw: unknown
 }
@@ -92,6 +106,33 @@ function mainStatusPill(status: string): string {
   return "unknown"
 }
 
+function formatIsoNoMs(ts: number): string {
+  const iso = new Date(ts).toISOString()
+  return iso.replace(/\.\d{3}Z$/, "Z")
+}
+
+function formatElapsed(ms: number): string {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1000))
+  const seconds = totalSeconds % 60
+  const totalMinutes = Math.floor(totalSeconds / 60)
+  const minutes = totalMinutes % 60
+  const totalHours = Math.floor(totalMinutes / 60)
+  const hours = totalHours % 24
+  const days = Math.floor(totalHours / 24)
+
+  if (days > 0) return hours > 0 ? `${days}d${hours}h` : `${days}d`
+  if (totalHours > 0) return minutes > 0 ? `${totalHours}h${minutes}m` : `${totalHours}h`
+  if (totalMinutes > 0) return seconds > 0 ? `${totalMinutes}m${seconds}s` : `${totalMinutes}m`
+  return `${seconds}s`
+}
+
+function formatTimeline(startAt: number | null, endAtMs: number): string {
+  if (typeof startAt !== "number") return ""
+  const start = formatIsoNoMs(startAt)
+  const elapsed = formatElapsed(endAtMs - startAt)
+  return `${start}: ${elapsed}`
+}
+
 export function buildDashboardPayload(opts: {
   projectRoot: string
   storage: OpenCodeStorageRoots
@@ -136,6 +177,41 @@ export function buildDashboardPayload(opts: {
   const mainCurrentModel = "currentModel" in main
     ? (main as MainSessionView).currentModel
     : null
+
+  const mainSessionTasks = (() => {
+    if (!sessionId) return []
+
+    const mainStatus = main.status
+    const status = mainStatus === "running_tool" || mainStatus === "thinking" || mainStatus === "busy"
+      ? "running"
+      : mainStatus === "idle"
+        ? "idle"
+        : "unknown"
+
+    const { toolCalls } = deriveToolCalls({
+      storage: opts.storage,
+      sessionId,
+    })
+
+    const startAt = sessionMeta?.time?.created ?? null
+    const endAtMs = status === "running" ? nowMs : (main.lastUpdated ?? nowMs)
+
+    return [
+      {
+        id: "main-session",
+        description: "Main session",
+        subline: sessionId,
+        agent: main.agent,
+        lastModel: mainCurrentModel,
+        status,
+        toolCalls: toolCalls.length,
+        lastTool: toolCalls[0]?.tool ?? "-",
+        timeline: formatTimeline(startAt, endAtMs),
+        sessionId,
+      },
+    ]
+  })()
+
   const payload: DashboardPayload = {
     mainSession: {
       agent: main.agent,
@@ -143,6 +219,7 @@ export function buildDashboardPayload(opts: {
       currentTool: main.currentTool ?? "-",
       lastUpdatedLabel: formatIso(main.lastUpdated),
       session: main.sessionLabel,
+      sessionId: sessionId ?? null,
       statusPill: mainStatusPill(main.status),
     },
     planProgress: {
@@ -164,6 +241,7 @@ export function buildDashboardPayload(opts: {
       timeline: typeof t.timeline === "string" ? t.timeline : "",
       sessionId: t.sessionId ?? null,
     })),
+    mainSessionTasks,
     timeSeries,
     raw: null,
   }
@@ -172,6 +250,7 @@ export function buildDashboardPayload(opts: {
     mainSession: payload.mainSession,
     planProgress: payload.planProgress,
     backgroundTasks: payload.backgroundTasks,
+    mainSessionTasks: payload.mainSessionTasks,
     timeSeries: payload.timeSeries,
   }
   return payload

package/src/server/dev.ts

@@ -35,7 +35,7 @@ const store = createDashboardStore({
   pollIntervalMs: 2000,
 })
 
-app.route("/api", createApi({ store, storageRoot }))
+app.route("/api", createApi({ store, storageRoot, projectRoot: resolvedProjectPath }))
 
 Bun.serve({
   fetch: app.fetch,

package/src/server/start.ts

@@ -30,7 +30,7 @@ const store = createDashboardStore({
   pollIntervalMs: 2000,
 })
 
-app.route('/api', createApi({ store, storageRoot }))
+app.route('/api', createApi({ store, storageRoot, projectRoot: project }))
 
 const distRoot = join(import.meta.dir, '../../dist')
 

package/src/styles.css

@@ -161,6 +161,64 @@ body {
   transform: translateY(0px);
 }
 
+.fieldRow {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 10px;
+}
+
+.field {
+  border: 1px solid rgba(31, 36, 38, 0.14);
+  background: rgba(255, 255, 255, 0.64);
+  padding: 9px 12px;
+  border-radius: 999px;
+  color: var(--ink);
+  font-size: 12px;
+  line-height: 1;
+  box-shadow: 0 6px 16px rgba(29, 32, 33, 0.06);
+  transition: transform 120ms ease, background 120ms ease, border-color 120ms ease;
+  min-width: 0;
+}
+
+.field:hover {
+  transform: translateY(-1px);
+  background: rgba(255, 255, 255, 0.78);
+  border-color: rgba(31, 36, 38, 0.18);
+}
+
+.field:active {
+  transform: translateY(0px);
+}
+
+.field:focus-visible {
+  outline: 2px solid rgba(15, 90, 81, 0.30);
+  outline-offset: 2px;
+}
+
+.field:disabled {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+select.field {
+  appearance: none;
+  padding-right: 34px;
+  background-image:
+    linear-gradient(45deg, transparent 50%, rgba(31, 36, 38, 0.50) 50%),
+    linear-gradient(135deg, rgba(31, 36, 38, 0.50) 50%, transparent 50%);
+  background-position:
+    calc(100% - 18px) 50%,
+    calc(100% - 13px) 50%;
+  background-size: 5px 5px;
+  background-repeat: no-repeat;
+}
+
+input.field {
+  appearance: none;
+  flex: 1 1 220px;
+}
+
 .pill {
   display: inline-flex;
   align-items: center;

package/src/time-series-ui.test.tsx

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "vitest";
+import * as React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import {
+  TimeSeriesActivitySection,
+  computeMainAgentsScaleMax,
+  computeOtherMainAgentsCount,
+} from "./App";
+
+type TimeSeriesProps = React.ComponentProps<typeof TimeSeriesActivitySection>;
+
+function mkTimeSeries(override?: Partial<TimeSeriesProps["timeSeries"]>): TimeSeriesProps["timeSeries"] {
+  const buckets = 3;
+  const mkSeries = (id: TimeSeriesProps["timeSeries"]["series"][number]["id"], values: number[]) => ({
+    id,
+    label: id,
+    tone: "muted" as const,
+    values,
+  });
+
+  return {
+    windowMs: 300_000,
+    buckets,
+    bucketMs: 2_000,
+    anchorMs: 0,
+    serverNowMs: 0,
+    series: [
+      mkSeries("overall-main", [0, 0, 0]),
+      mkSeries("agent:sisyphus", [0, 0, 0]),
+      mkSeries("agent:prometheus", [0, 0, 0]),
+      mkSeries("agent:atlas", [0, 0, 0]),
+      mkSeries("background-total", [0, 0, 0]),
+    ],
+    ...override,
+  };
+}
+
+describe("TimeSeriesActivitySection (SSR)", () => {
+  it("should not render top axis and should keep bottom axis", () => {
+    // #given
+    const timeSeries = mkTimeSeries();
+
+    // #when
+    const html = renderToStaticMarkup(<TimeSeriesActivitySection timeSeries={timeSeries} />);
+
+    // #then
+    expect(html).not.toContain("timeSeriesAxisTop");
+    expect(html).toContain("timeSeriesAxisBottom");
+  });
+
+  it("should render sand bars for other main agents when derived otherMain is non-zero", () => {
+    // #given
+    const timeSeries = mkTimeSeries({
+      series: [
+        { id: "overall-main", label: "Overall", tone: "muted", values: [10, 0, 0] },
+        { id: "agent:sisyphus", label: "Sisyphus", tone: "teal", values: [0, 0, 0] },
+        { id: "agent:prometheus", label: "Prometheus", tone: "red", values: [0, 0, 0] },
+        { id: "agent:atlas", label: "Atlas", tone: "green", values: [0, 0, 0] },
+        { id: "background-total", label: "Background", tone: "muted", values: [0, 0, 0] },
+      ],
+    });
+
+    // #when
+    const html = renderToStaticMarkup(<TimeSeriesActivitySection timeSeries={timeSeries} />);
+
+    // #then
+    expect(html).toContain("timeSeriesBar--sand");
+  });
+});
+
+describe("time-series helpers", () => {
+  it("computeOtherMainAgentsCount should clamp to >= 0 and ignore invalid numbers", () => {
+    // #given
+    const value = computeOtherMainAgentsCount({
+      overall: 10,
+      background: 3,
+      sisyphus: 2,
+      prometheus: 1,
+      atlas: 0,
+    });
+
+    // #then
+    expect(value).toBe(4);
+
+    expect(
+      computeOtherMainAgentsCount({
+        overall: NaN,
+        background: Infinity,
+        sisyphus: -1,
+        prometheus: 0,
+        atlas: 0,
+      })
+    ).toBe(0);
+  });
+
+  it("computeMainAgentsScaleMax should include otherMain in the max", () => {
+    // #given
+    const scaleMax = computeMainAgentsScaleMax({
+      buckets: 1,
+      overallValues: [10],
+      backgroundValues: [0],
+      sisyphusValues: [0],
+      prometheusValues: [0],
+      atlasValues: [0],
+    });
+
+    // #then
+    expect(scaleMax).toBe(10);
+  });
+});