oh-my-opencode-dashboard 0.0.3 → 0.0.4

package/src/ingest/session.test.ts

@@ -8,6 +8,7 @@ import {
   pickActiveSessionId,
   readMainSessionMetas,
 } from "./session"
+import { extractModelString, pickLatestModelString } from "./model"
 
 function mkStorageRoot(): string {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "omo-storage-"))
@@ -217,4 +218,122 @@ describe("getMainSessionView", () => {
 
     expect(view.status).toBe("thinking")
   })
+
+  it("returns null currentModel when no model metadata exists", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = "/tmp/project"
+    const sessionId = "ses_1"
+
+    const messageDir = path.join(storage.message, sessionId)
+    fs.mkdirSync(messageDir, { recursive: true })
+
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(messageDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: sessionId,
+        role: "assistant",
+        agent: "sisyphus",
+        time: { created: 1000 },
+      }),
+      "utf8"
+    )
+
+    // #given no model metadata in messages
+    // #when deriving main session view
+    const view = getMainSessionView({
+      projectRoot,
+      sessionId,
+      storage,
+      sessionMeta: null,
+      nowMs: 50_000,
+    })
+
+    // #then currentModel is null
+    expect(view.currentModel).toBeNull()
+  })
+})
+
+describe("extractModelString", () => {
+  it("supports assistant flat and user nested shapes", () => {
+    // #given assistant flat model
+    const assistantMeta = {
+      role: "assistant",
+      providerID: "openai",
+      modelID: "gpt-5.2",
+    }
+
+    // #when extracting model string
+    const assistantModel = extractModelString(assistantMeta)
+
+    // #then uses provider/model format
+    expect(assistantModel).toBe("openai/gpt-5.2")
+
+    // #given user nested model
+    const userMeta = {
+      role: "user",
+      model: { providerID: "anthropic", modelID: "claude-opus-4.5" },
+    }
+
+    // #when extracting model string
+    const userModel = extractModelString(userMeta)
+
+    // #then uses provider/model format
+    expect(userModel).toBe("anthropic/claude-opus-4.5")
+  })
+})
+
+describe("pickLatestModelString", () => {
+  it("prefers latest assistant model over newer user model", () => {
+    const metas = [
+      {
+        id: "msg_1",
+        role: "assistant",
+        time: { created: 1000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      },
+      {
+        id: "msg_2",
+        role: "user",
+        time: { created: 2000 },
+        model: { providerID: "anthropic", modelID: "claude-opus-4.5" },
+      },
+    ]
+
+    // #given assistant with model exists but user is newer
+    // #when picking latest model string
+    const picked = pickLatestModelString(metas)
+
+    // #then assistant model is preferred
+    expect(picked).toBe("openai/gpt-5.2")
+  })
+
+  it("uses deterministic ordering by created then id", () => {
+    const metas = [
+      {
+        id: "msg_a",
+        role: "assistant",
+        time: { created: 3000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      },
+      {
+        id: "msg_b",
+        role: "assistant",
+        time: { created: 3000 },
+        providerID: "openai",
+        modelID: "gpt-5.2-turbo",
+      },
+    ]
+
+    // #given same created time, higher id wins
+    // #when picking latest model string
+    const picked = pickLatestModelString(metas)
+
+    // #then picks model from msg_b
+    expect(picked).toBe("openai/gpt-5.2-turbo")
+  })
 })

package/src/ingest/session.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs"
 import * as path from "node:path"
+import { pickLatestModelString } from "./model"
 import { getOpenCodeStorageDir, realpathSafe } from "./paths"
 
 export type SessionMetadata = {
@@ -32,6 +33,7 @@ export type StoredToolPart = {
 export type MainSessionView = {
   agent: string
   currentTool: string | null
+  currentModel: string | null
   lastUpdated: number | null
   sessionLabel: string
   status: "busy" | "idle" | "unknown" | "running_tool" | "thinking"
@@ -253,6 +255,7 @@ export function getMainSessionView(opts: {
   // Scan recent messages for any in-flight tool parts
   let activeTool: { tool: string; status: string } | null = null
   const recentMetas = readRecentMessageMetas(messageDir, 200)
+  const currentModel = pickLatestModelString(recentMetas)
   
   // Iterate newest → oldest, early-exit on first tool part with pending/running status
   for (const meta of recentMetas) {
@@ -276,6 +279,7 @@ export function getMainSessionView(opts: {
   return {
     agent,
     currentTool: activeTool?.tool ?? null,
+    currentModel,
     lastUpdated,
     sessionLabel,
     status,

package/src/server/api.test.ts

@@ -6,7 +6,7 @@ describe('API Routes', () => {
     const api = createApi({
       getSnapshot: () => ({
         mainSession: { agent: "x", currentTool: "-", lastUpdatedLabel: "never", session: "s", statusPill: "idle" },
-        planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started" },
+        planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started", steps: [] },
         backgroundTasks: [],
         timeSeries: {
           windowMs: 0,
@@ -29,7 +29,7 @@ describe('API Routes', () => {
     const api = createApi({
       getSnapshot: () => ({
         mainSession: { agent: "x", currentTool: "-", lastUpdatedLabel: "never", session: "s", statusPill: "idle" },
-        planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started" },
+        planProgress: { name: "p", completed: 0, total: 0, path: "", statusPill: "not started", steps: [] },
         backgroundTasks: [{ id: "1", description: "d", agent: "a", status: "queued", toolCalls: 0, lastTool: "-", timeline: "" }],
         timeSeries: {
           windowMs: 0,

package/src/server/dashboard.test.ts

@@ -75,6 +75,7 @@ describe("buildDashboardPayload", () => {
       expect(payload.mainSession.statusPill).toBe("running tool")
       expect(payload.mainSession.currentTool).toBe("delegate_task")
       expect(payload.mainSession.agent).toBe("sisyphus")
+      expect(payload.mainSession.currentModel).toBeNull()
       
       expect(payload.raw).not.toHaveProperty("prompt")
       expect(payload.raw).not.toHaveProperty("input")
@@ -147,6 +148,7 @@ describe("buildDashboardPayload", () => {
 
       expect(payload).toHaveProperty("timeSeries")
       expect(payload.raw).toHaveProperty("timeSeries")
+      expect(payload.mainSession.currentModel).toBeNull()
 
       const sensitiveKeys = ["prompt", "input", "output", "error", "state"]
 
@@ -175,4 +177,141 @@ describe("buildDashboardPayload", () => {
       fs.rmSync(projectRoot, { recursive: true, force: true })
     }
   })
+
+  it("includes latest model strings for main and background sessions", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+    const sessionId = "ses_with_models"
+    const backgroundSessionId = "ses_bg_1"
+    const messageId = "msg_1"
+    const projectID = "proj_1"
+
+    try {
+      const sessionMetaDir = path.join(storage.session, projectID)
+      fs.mkdirSync(sessionMetaDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(sessionMetaDir, `${sessionId}.json`),
+        JSON.stringify({
+          id: sessionId,
+          projectID,
+          directory: projectRoot,
+          time: { created: 1000, updated: 1000 },
+        }),
+        "utf8"
+      )
+      fs.writeFileSync(
+        path.join(sessionMetaDir, `${backgroundSessionId}.json`),
+        JSON.stringify({
+          id: backgroundSessionId,
+          projectID,
+          directory: projectRoot,
+          parentID: sessionId,
+          title: "Background: model task",
+          time: { created: 1000, updated: 1100 },
+        }),
+        "utf8"
+      )
+
+      const messageDir = path.join(storage.message, sessionId)
+      fs.mkdirSync(messageDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(messageDir, `${messageId}.json`),
+        JSON.stringify({
+          id: messageId,
+          sessionID: sessionId,
+          role: "assistant",
+          agent: "sisyphus",
+          time: { created: 1000 },
+        }),
+        "utf8"
+      )
+
+      const partDir = path.join(storage.part, messageId)
+      fs.mkdirSync(partDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(partDir, "part_1.json"),
+        JSON.stringify({
+          id: "part_1",
+          sessionID: sessionId,
+          messageID: messageId,
+          type: "tool",
+          callID: "call_1",
+          tool: "delegate_task",
+          state: {
+            status: "completed",
+            input: {
+              run_in_background: true,
+              description: "model task",
+              subagent_type: "explore",
+            },
+          },
+        }),
+        "utf8"
+      )
+
+      const backgroundMessageDir = path.join(storage.message, backgroundSessionId)
+      fs.mkdirSync(backgroundMessageDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(backgroundMessageDir, "msg_bg_1.json"),
+        JSON.stringify({
+          id: "msg_bg_1",
+          sessionID: backgroundSessionId,
+          role: "assistant",
+          providerID: "openai",
+          modelID: "gpt-4o",
+          time: { created: 1100 },
+        }),
+        "utf8"
+      )
+
+      const payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 2000,
+      })
+
+      expect(payload.mainSession.currentModel).toBeNull()
+      expect(payload.backgroundTasks).toHaveLength(1)
+      expect(payload.backgroundTasks[0]?.lastModel).toBe("openai/gpt-4o")
+      expect(payload.raw).toHaveProperty("backgroundTasks.0.lastModel", "openai/gpt-4o")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
+
+  it("does not include elapsed time in status pill when status is unknown", () => {
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "omo-project-"))
+    const sessionId = "ses_unknown"
+    const projectID = "proj_1"
+
+    try {
+      const sessionMetaDir = path.join(storage.session, projectID)
+      fs.mkdirSync(sessionMetaDir, { recursive: true })
+      fs.writeFileSync(
+        path.join(sessionMetaDir, `${sessionId}.json`),
+        JSON.stringify({
+          id: sessionId,
+          projectID,
+          directory: projectRoot,
+          time: { created: 1000, updated: 1000 },
+        }),
+        "utf8"
+      )
+
+      const payload = buildDashboardPayload({
+        projectRoot,
+        storage,
+        nowMs: 65_000,
+      })
+
+      expect(payload.mainSession.statusPill).toBe("unknown")
+    } finally {
+      fs.rmSync(storageRoot, { recursive: true, force: true })
+      fs.rmSync(projectRoot, { recursive: true, force: true })
+    }
+  })
 })

package/src/server/dashboard.ts

@@ -3,9 +3,40 @@ import * as path from "node:path"
 import { readBoulderState, readPlanProgress, readPlanSteps, type PlanStep } from "../ingest/boulder"
 import { deriveBackgroundTasks } from "../ingest/background-tasks"
 import { deriveTimeSeriesActivity, type TimeSeriesPayload } from "../ingest/timeseries"
-import { getMainSessionView, getStorageRoots, pickActiveSessionId, readMainSessionMetas, type OpenCodeStorageRoots, type SessionMetadata } from "../ingest/session"
+import { getMainSessionView, getStorageRoots, pickActiveSessionId, readMainSessionMetas, type MainSessionView, type OpenCodeStorageRoots, type SessionMetadata } from "../ingest/session"
 
 export type DashboardPayload = {
+  mainSession: {
+    agent: string
+    currentModel: string | null
+    currentTool: string
+    lastUpdatedLabel: string
+    session: string
+    statusPill: string
+  }
+  planProgress: {
+    name: string
+    completed: number
+    total: number
+    path: string
+    statusPill: string
+    steps: PlanStep[]
+  }
+  backgroundTasks: Array<{
+    id: string
+    description: string
+    agent: string
+    lastModel: string | null
+    status: string
+    toolCalls: number
+    lastTool: string
+    timeline: string
+  }>
+  timeSeries: TimeSeriesPayload
+  raw: unknown
+}
+
+export type LegacyDashboardPayload = {
   mainSession: {
     agent: string
     currentTool: string
@@ -35,7 +66,7 @@ export type DashboardPayload = {
 }
 
 export type DashboardStore = {
-  getSnapshot: () => DashboardPayload
+  getSnapshot: () => DashboardPayload | LegacyDashboardPayload
 }
 
 function formatIso(ts: number | null): string {
@@ -101,10 +132,13 @@ export function buildDashboardPayload(opts: {
     mainSessionId: sessionId ?? null,
     nowMs,
   })
-
+  const mainCurrentModel = "currentModel" in main
+    ? (main as MainSessionView).currentModel
+    : null
   const payload: DashboardPayload = {
     mainSession: {
       agent: main.agent,
+      currentModel: mainCurrentModel,
       currentTool: main.currentTool ?? "-",
       lastUpdatedLabel: formatIso(main.lastUpdated),
       session: main.sessionLabel,
@@ -122,6 +156,7 @@ export function buildDashboardPayload(opts: {
       id: t.id,
       description: t.description,
       agent: t.agent,
+      lastModel: t.lastModel ?? null,
       status: t.status,
       toolCalls: t.toolCalls ?? 0,
       lastTool: t.lastTool ?? "-",

package/src/timeseries-stacked.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect } from "vitest";
+import { computeStackedSegments, AgentCounts, StackedSegment } from "./timeseries-stacked";
+
+describe("computeStackedSegments", () => {
+  describe("Edge cases", () => {
+    it("should return empty array when chartHeight <= 0", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      
+      expect(computeStackedSegments(counts, 20, 0)).toEqual([]);
+      expect(computeStackedSegments(counts, 20, -5)).toEqual([]);
+    });
+
+    it("should return empty array when scaleMax <= 0", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      
+      expect(computeStackedSegments(counts, 0, 100)).toEqual([]);
+      expect(computeStackedSegments(counts, -10, 100)).toEqual([]);
+    });
+
+    it("should return empty array when all counts are zero", () => {
+      const counts: AgentCounts = { sisyphus: 0, prometheus: 0, atlas: 0 };
+      
+      const result = computeStackedSegments(counts, 20, 100);
+      expect(result).toEqual([]);
+    });
+
+    it("should handle invalid/missing counts gracefully", () => {
+      const invalidCounts = {
+        sisyphus: NaN,
+        prometheus: Infinity,
+        atlas: -5,
+      } as unknown as AgentCounts;
+      
+      const result = computeStackedSegments(invalidCounts, 20, 100);
+      expect(result).toEqual([]);
+    });
+
+    it("should handle mixed valid/invalid counts", () => {
+      const mixedCounts = {
+        sisyphus: 10,
+        prometheus: NaN,
+        atlas: -3,
+      } as unknown as AgentCounts;
+      
+      const result = computeStackedSegments(mixedCounts, 20, 100);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        tone: "teal",
+        y: 50,
+        height: 50,
+      });
+    });
+  });
+
+  describe("Single agent scenarios", () => {
+    it("should return one segment when only sisyphus is non-zero", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 0, atlas: 0 };
+      
+      const result = computeStackedSegments(counts, 20, 100);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        tone: "teal",
+        y: 50,
+        height: 50,
+      });
+    });
+
+    it("should return one segment when only prometheus is non-zero", () => {
+      const counts: AgentCounts = { sisyphus: 0, prometheus: 15, atlas: 0 };
+      
+      const result = computeStackedSegments(counts, 30, 120);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        tone: "red",
+        y: 60,
+        height: 60,
+      });
+    });
+
+    it("should return one segment when only atlas is non-zero", () => {
+      const counts: AgentCounts = { sisyphus: 0, prometheus: 0, atlas: 8 };
+      
+      const result = computeStackedSegments(counts, 16, 80);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        tone: "green",
+        y: 40,
+        height: 40,
+      });
+    });
+
+    it("should round to at least 1px for non-zero values", () => {
+      const counts: AgentCounts = { sisyphus: 1, prometheus: 0, atlas: 0 };
+      
+      const result = computeStackedSegments(counts, 1000, 100);
+      expect(result).toHaveLength(1);
+      expect(result[0].height).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe("Multiple agent scenarios", () => {
+    it("should return multiple segments in correct order (bottom to top)", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 20, atlas: 15 };
+      
+      const result = computeStackedSegments(counts, 50, 100);
+      expect(result).toHaveLength(3);
+      
+      // Check order: teal (sisyphus) -> red (prometheus) -> green (atlas)
+      expect(result[0].tone).toBe("teal");
+      expect(result[1].tone).toBe("red");
+      expect(result[2].tone).toBe("green");
+      
+      // Check positions (y increases upward, so atlas should have smallest y)
+      expect(result[0].y).toBeGreaterThan(result[1].y);
+      expect(result[1].y).toBeGreaterThan(result[2].y);
+    });
+
+    it("should correctly calculate heights for all agents", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 20, atlas: 15 };
+      
+      const result = computeStackedSegments(counts, 50, 100);
+      const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
+      
+      expect(totalHeight).toBeLessThanOrEqual(100);
+      
+      // Expected heights: 20, 40, 30
+      expect(result[0].height).toBe(20); // sisyphus
+      expect(result[1].height).toBe(40); // prometheus  
+      expect(result[2].height).toBe(30); // atlas
+    });
+
+    it("should handle zero values mixed with non-zero values", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 0, atlas: 15 };
+      
+      const result = computeStackedSegments(counts, 30, 90);
+      expect(result).toHaveLength(2);
+      
+      // Should only have teal (sisyphus) and green (atlas)
+      expect(result[0].tone).toBe("teal");
+      expect(result[1].tone).toBe("green");
+      
+      // Check positioning
+      expect(result[0].y).toBeGreaterThan(result[1].y);
+    });
+  });
+
+  describe("Clamping and overflow behavior", () => {
+    it("should ensure sum of heights never exceeds chartHeight", () => {
+      const counts: AgentCounts = { sisyphus: 100, prometheus: 100, atlas: 100 };
+      
+      const result = computeStackedSegments(counts, 100, 50); // Should overflow
+      const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
+      
+      expect(totalHeight).toBeLessThanOrEqual(50);
+    });
+
+    it("should preserve at least 1px for non-zero agents when possible", () => {
+      const counts: AgentCounts = { sisyphus: 1, prometheus: 1, atlas: 1 };
+      
+      const result = computeStackedSegments(counts, 100, 10);
+      
+      // All agents should be visible with at least 1px each
+      expect(result).toHaveLength(3);
+      expect(result.every(seg => seg.height >= 1)).toBe(true);
+    });
+
+    it("should distribute overflow reduction fairly", () => {
+      const counts: AgentCounts = { sisyphus: 40, prometheus: 35, atlas: 25 };
+      
+      const result = computeStackedSegments(counts, 100, 80);
+      const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
+      
+      expect(totalHeight).toBeLessThanOrEqual(80);
+      
+      // Larger segments should be reduced more
+      const heights = result.map(seg => seg.height);
+      expect(Math.max(...heights)).toBeLessThanOrEqual(40); // Original largest was 40
+    });
+
+    it("should handle extreme overflow gracefully", () => {
+      const counts: AgentCounts = { sisyphus: 1000, prometheus: 1000, atlas: 1000 };
+      
+      const result = computeStackedSegments(counts, 100, 5);
+      const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
+      
+      expect(totalHeight).toBeLessThanOrEqual(5);
+      // Should still try to show all agents
+      expect(result.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe("Deterministic behavior", () => {
+    it("should produce identical results for identical inputs", () => {
+      const counts: AgentCounts = { sisyphus: 15, prometheus: 25, atlas: 10 };
+      
+      const result1 = computeStackedSegments(counts, 60, 100);
+      const result2 = computeStackedSegments(counts, 60, 100);
+      
+      expect(result1).toEqual(result2);
+    });
+
+    it("should maintain consistent segment order regardless of input magnitudes", () => {
+      const testCases = [
+        { sisyphus: 100, prometheus: 1, atlas: 1 },
+        { sisyphus: 1, prometheus: 100, atlas: 1 },
+        { sisyphus: 1, prometheus: 1, atlas: 100 },
+        { sisyphus: 50, prometheus: 25, atlas: 75 },
+      ] as AgentCounts[];
+      
+      testCases.forEach(counts => {
+        const result = computeStackedSegments(counts, 100, 100);
+        const tones = result.map(seg => seg.tone);
+        
+        if (result.length === 3) {
+          expect(tones).toEqual(["teal", "red", "green"]);
+        } else if (result.length === 2) {
+          // Should still be in correct order, just missing zero-valued agents
+          expect(tones).toEqual(expect.arrayContaining([
+            expect.stringMatching(/teal|red|green/)
+          ]));
+          // Check that order is preserved for present agents
+          const toneIndex = (t: string) => ["teal", "red", "green"].indexOf(t);
+          for (let i = 1; i < tones.length; i++) {
+            expect(toneIndex(tones[i])).toBeGreaterThan(toneIndex(tones[i-1]));
+          }
+        }
+      });
+    });
+  });
+
+  describe("Boundary conditions", () => {
+    it("should handle very small chartHeight", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      
+      const result = computeStackedSegments(counts, 20, 1);
+      const totalHeight = result.reduce((sum, seg) => sum + seg.height, 0);
+      
+      expect(totalHeight).toBeLessThanOrEqual(1);
+    });
+
+    it("should handle very large scaleMax", () => {
+      const counts: AgentCounts = { sisyphus: 10, prometheus: 5, atlas: 3 };
+      
+      const result = computeStackedSegments(counts, 1000000, 100);
+      
+      // Should produce very small but non-zero heights
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.every(seg => seg.height >= 1)).toBe(true);
+    });
+
+    it("should handle fractional results correctly", () => {
+      const counts: AgentCounts = { sisyphus: 1, prometheus: 1, atlas: 1 };
+      
+      const result = computeStackedSegments(counts, 3, 10);
+      
+      // All heights should be integers
+      expect(result.every(seg => Number.isInteger(seg.height))).toBe(true);
+      expect(result.every(seg => Number.isInteger(seg.y))).toBe(true);
+    });
+  });
+});