oh-my-opencode-dashboard 0.0.3 → 0.0.4

package/src/ingest/background-tasks.test.ts

@@ -1,7 +1,7 @@
-import * as fs from "node:fs"
 import * as os from "node:os"
 import * as path from "node:path"
-import { describe, expect, it } from "vitest"
+import * as fs from "node:fs"
+import { describe, expect, it, vi } from "vitest"
 import { deriveBackgroundTasks } from "./background-tasks"
 import { getStorageRoots } from "./session"
 
@@ -602,6 +602,7 @@ describe("deriveBackgroundTasks", () => {
     expect(rows[0].toolCalls).toBe(0) // No tool calls in fallback session
     expect(rows[0].lastTool).toBe(null)
     expect(rows[0].status).toBe("unknown") // Should be unknown since session exists but no tool calls
+    expect(rows[0].timeline).toBe("") // Unknown status should emit no timeline
   })
 
   it("links sync delegate_task rows to Background sessions when forced-to-background but waited", () => {
@@ -704,4 +705,296 @@ describe("deriveBackgroundTasks", () => {
     expect((rows[0] as unknown as Record<string, unknown>).input).toBeUndefined()
     expect((rows[0] as unknown as Record<string, unknown>).state).toBeUndefined()
   })
+
+  it("derives lastModel from background session assistant metas", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+
+    const msgDir = path.join(storage.message, mainSessionId)
+    fs.mkdirSync(msgDir, { recursive: true })
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(msgDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: mainSessionId,
+        role: "assistant",
+        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: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_1",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Model scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+
+    const projectID = "proj"
+    const sessDir = path.join(storage.session, projectID)
+    fs.mkdirSync(sessDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(sessDir, "ses_child.json"),
+      JSON.stringify({
+        id: "ses_child",
+        projectID,
+        directory: "/tmp/project",
+        title: "Background: Model scan",
+        parentID: mainSessionId,
+        time: { created: 1500, updated: 1500 },
+      }),
+      "utf8"
+    )
+
+    const childMsgDir = path.join(storage.message, "ses_child")
+    fs.mkdirSync(childMsgDir, { recursive: true })
+    const childMsgId = "msg_child"
+    fs.writeFileSync(
+      path.join(childMsgDir, `${childMsgId}.json`),
+      JSON.stringify({
+        id: childMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 2000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      }),
+      "utf8"
+    )
+
+    // #when
+    const rows = deriveBackgroundTasks({ storage, mainSessionId })
+
+    // #then
+    expect(rows.length).toBe(1)
+    expect(rows[0].lastModel).toBe("openai/gpt-5.2")
+  })
+
+  it("orders lastModel by time.created over file mtime", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+
+    const msgDir = path.join(storage.message, mainSessionId)
+    fs.mkdirSync(msgDir, { recursive: true })
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(msgDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: mainSessionId,
+        role: "assistant",
+        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: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_1",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Ordering scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+
+    const projectID = "proj"
+    const sessDir = path.join(storage.session, projectID)
+    fs.mkdirSync(sessDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(sessDir, "ses_child.json"),
+      JSON.stringify({
+        id: "ses_child",
+        projectID,
+        directory: "/tmp/project",
+        title: "Background: Ordering scan",
+        parentID: mainSessionId,
+        time: { created: 1500, updated: 1500 },
+      }),
+      "utf8"
+    )
+
+    const childMsgDir = path.join(storage.message, "ses_child")
+    fs.mkdirSync(childMsgDir, { recursive: true })
+    const olderMsgId = "msg_older"
+    const newerMsgId = "msg_newer"
+
+    fs.writeFileSync(
+      path.join(childMsgDir, `${newerMsgId}.json`),
+      JSON.stringify({
+        id: newerMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 3000 },
+        providerID: "openai",
+        modelID: "gpt-newer",
+      }),
+      "utf8"
+    )
+    fs.writeFileSync(
+      path.join(childMsgDir, `${olderMsgId}.json`),
+      JSON.stringify({
+        id: olderMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 1000 },
+        providerID: "openai",
+        modelID: "gpt-older",
+      }),
+      "utf8"
+    )
+
+    // #when
+    const rows = deriveBackgroundTasks({ storage, mainSessionId })
+
+    // #then
+    expect(rows.length).toBe(1)
+    expect(rows[0].lastModel).toBe("openai/gpt-newer")
+  })
+
+  it("memoizes background session reads for shared sessionId", () => {
+    // #given
+    const storageRoot = mkStorageRoot()
+    const storage = getStorageRoots(storageRoot)
+    const mainSessionId = "ses_main"
+    
+    // Clear any previous mock state
+    vi.clearAllMocks()
+
+    const msgDir = path.join(storage.message, mainSessionId)
+    fs.mkdirSync(msgDir, { recursive: true })
+    const messageID = "msg_1"
+    fs.writeFileSync(
+      path.join(msgDir, `${messageID}.json`),
+      JSON.stringify({
+        id: messageID,
+        sessionID: mainSessionId,
+        role: "assistant",
+        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: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_1",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Memo scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+    fs.writeFileSync(
+      path.join(partDir, "part_2.json"),
+      JSON.stringify({
+        id: "part_2",
+        sessionID: mainSessionId,
+        messageID,
+        type: "tool",
+        callID: "call_2",
+        tool: "delegate_task",
+        state: {
+          status: "completed",
+          input: {
+            run_in_background: true,
+            description: "Memo scan",
+            subagent_type: "explore",
+          },
+        },
+      }),
+      "utf8"
+    )
+
+    const projectID = "proj"
+    const sessDir = path.join(storage.session, projectID)
+    fs.mkdirSync(sessDir, { recursive: true })
+    fs.writeFileSync(
+      path.join(sessDir, "ses_child.json"),
+      JSON.stringify({
+        id: "ses_child",
+        projectID,
+        directory: "/tmp/project",
+        title: "Background: Memo scan",
+        parentID: mainSessionId,
+        time: { created: 1500, updated: 1500 },
+      }),
+      "utf8"
+    )
+
+    const childMsgDir = path.join(storage.message, "ses_child")
+    fs.mkdirSync(childMsgDir, { recursive: true })
+    const childMsgId = "msg_child"
+    fs.writeFileSync(
+      path.join(childMsgDir, `${childMsgId}.json`),
+      JSON.stringify({
+        id: childMsgId,
+        sessionID: "ses_child",
+        role: "assistant",
+        time: { created: 2000 },
+        providerID: "openai",
+        modelID: "gpt-5.2",
+      }),
+      "utf8"
+    )
+
+    const readdirSync = vi.fn(fs.readdirSync)
+    const fsLike = {
+      readFileSync: fs.readFileSync,
+      readdirSync,
+      existsSync: fs.existsSync,
+      statSync: fs.statSync,
+    }
+
+    // #when
+    const rows = deriveBackgroundTasks({ storage, mainSessionId, fs: fsLike })
+
+    // #then
+    const backgroundReads = readdirSync.mock.calls.filter((call) => call[0] === childMsgDir)
+    expect(rows.length).toBe(2)
+    expect(backgroundReads.length).toBe(1)
+  })
 })

package/src/ingest/background-tasks.ts

@@ -2,6 +2,9 @@ import * as fs from "node:fs"
 import * as path from "node:path"
 import type { OpenCodeStorageRoots, SessionMetadata, StoredMessageMeta, StoredToolPart } from "./session"
 import { getMessageDir } from "./session"
+import { pickLatestModelString } from "./model"
+
+type FsLike = Pick<typeof fs, "readFileSync" | "readdirSync" | "existsSync" | "statSync"> 
 
 export type BackgroundTaskRow = {
   id: string
@@ -10,6 +13,7 @@ export type BackgroundTaskRow = {
   status: "queued" | "running" | "completed" | "error" | "unknown"
   toolCalls: number | null
   lastTool: string | null
+  lastModel: string | null
   timeline: string
   sessionId: string | null
 }
@@ -24,31 +28,31 @@ function clampString(value: unknown, maxLen: number): string | null {
   return s.length <= maxLen ? s : s.slice(0, maxLen)
 }
 
-function readJsonFile<T>(filePath: string): T | null {
+function readJsonFile<T>(filePath: string, fsLike: FsLike): T | null {
   try {
-    const content = fs.readFileSync(filePath, "utf8")
+    const content = fsLike.readFileSync(filePath, "utf8")
     return JSON.parse(content) as T
   } catch {
     return null
   }
 }
 
-function listJsonFiles(dir: string): string[] {
+function listJsonFiles(dir: string, fsLike: FsLike): string[] {
   try {
-    return fs.readdirSync(dir).filter((f) => f.endsWith(".json"))
+    return fsLike.readdirSync(dir).filter((f) => f.endsWith(".json"))
   } catch {
     return []
   }
 }
 
-function readToolPartsForMessage(storage: OpenCodeStorageRoots, messageID: string): StoredToolPart[] {
+function readToolPartsForMessage(storage: OpenCodeStorageRoots, messageID: string, fsLike: FsLike): StoredToolPart[] {
   const partDir = path.join(storage.part, messageID)
-  if (!fs.existsSync(partDir)) return []
+  if (!fsLike.existsSync(partDir)) return []
 
-  const files = listJsonFiles(partDir).sort()
+  const files = listJsonFiles(partDir, fsLike).sort()
   const parts: StoredToolPart[] = []
   for (const f of files) {
-    const p = readJsonFile<StoredToolPart>(path.join(partDir, f))
+    const p = readJsonFile<StoredToolPart>(path.join(partDir, f), fsLike)
     if (p && p.type === "tool" && typeof p.tool === "string" && p.state && typeof p.state === "object") {
       parts.push(p)
     }
@@ -56,14 +60,14 @@ function readToolPartsForMessage(storage: OpenCodeStorageRoots, messageID: strin
   return parts
 }
 
-function readRecentMessageMetas(messageDir: string, maxMessages: number): StoredMessageMeta[] {
-  if (!messageDir || !fs.existsSync(messageDir)) return []
-  const files = listJsonFiles(messageDir)
+function readRecentMessageMetas(messageDir: string, maxMessages: number, fsLike: FsLike): StoredMessageMeta[] {
+  if (!messageDir || !fsLike.existsSync(messageDir)) return []
+  const files = listJsonFiles(messageDir, fsLike)
     .map((f) => ({
       f,
       mtime: (() => {
         try {
-          return fs.statSync(path.join(messageDir, f)).mtimeMs
+          return fsLike.statSync(path.join(messageDir, f)).mtimeMs
         } catch {
           return 0
         }
@@ -74,22 +78,22 @@ function readRecentMessageMetas(messageDir: string, maxMessages: number): Stored
 
   const metas: StoredMessageMeta[] = []
   for (const item of files) {
-    const meta = readJsonFile<StoredMessageMeta>(path.join(messageDir, item.f))
+    const meta = readJsonFile<StoredMessageMeta>(path.join(messageDir, item.f), fsLike)
     if (meta && typeof meta.id === "string") metas.push(meta)
   }
   return metas
 }
 
-export function readAllSessionMetas(sessionStorage: string): SessionMetadata[] {
-  if (!fs.existsSync(sessionStorage)) return []
+export function readAllSessionMetas(sessionStorage: string, fsLike: FsLike = fs): SessionMetadata[] {
+  if (!fsLike.existsSync(sessionStorage)) return []
   const metas: SessionMetadata[] = []
   try {
-    const projectDirs = fs.readdirSync(sessionStorage, { withFileTypes: true })
+    const projectDirs = fsLike.readdirSync(sessionStorage, { withFileTypes: true })
     for (const d of projectDirs) {
       if (!d.isDirectory()) continue
       const projectPath = path.join(sessionStorage, d.name)
-      for (const file of listJsonFiles(projectPath)) {
-        const meta = readJsonFile<SessionMetadata>(path.join(projectPath, file))
+      for (const file of listJsonFiles(projectPath, fsLike)) {
+        const meta = readJsonFile<SessionMetadata>(path.join(projectPath, file), fsLike)
         if (meta && typeof meta.id === "string") metas.push(meta)
       }
     }
@@ -152,9 +156,11 @@ function findTaskSessionId(opts: {
   return candidates[0]?.id ?? null
 }
 
-function deriveBackgroundSessionStats(storage: OpenCodeStorageRoots, sessionId: string): { toolCalls: number; lastTool: string | null; lastUpdateAt: number | null } {
-  const messageDir = getMessageDir(storage.message, sessionId)
-  const metas = readRecentMessageMetas(messageDir, 200)
+function deriveBackgroundSessionStats(
+  storage: OpenCodeStorageRoots,
+  metas: StoredMessageMeta[],
+  fsLike: FsLike
+): { toolCalls: number; lastTool: string | null; lastUpdateAt: number | null } {
   let toolCalls = 0
   let lastTool: string | null = null
   let lastUpdateAt: number | null = null
@@ -170,7 +176,7 @@ function deriveBackgroundSessionStats(storage: OpenCodeStorageRoots, sessionId:
   for (const meta of ordered) {
     const created = meta.time?.created
     if (typeof created === "number") lastUpdateAt = created
-    const parts = readToolPartsForMessage(storage, meta.id)
+    const parts = readToolPartsForMessage(storage, meta.id, fsLike)
     for (const p of parts) {
       toolCalls += 1
       lastTool = p.tool
@@ -211,11 +217,42 @@ export function deriveBackgroundTasks(opts: {
   storage: OpenCodeStorageRoots
   mainSessionId: string
   nowMs?: number
+  fs?: FsLike
 }): BackgroundTaskRow[] {
+  const fsLike: FsLike = opts.fs ?? fs
   const nowMs = opts.nowMs ?? Date.now()
   const messageDir = getMessageDir(opts.storage.message, opts.mainSessionId)
-  const metas = readRecentMessageMetas(messageDir, 200)
-  const allSessionMetas = readAllSessionMetas(opts.storage.session)
+  const metas = readRecentMessageMetas(messageDir, 200, fsLike)
+  const allSessionMetas = readAllSessionMetas(opts.storage.session, fsLike)
+  const backgroundMessageCache = new Map<string, StoredMessageMeta[]>()
+  const backgroundStatsCache = new Map<string, { toolCalls: number; lastTool: string | null; lastUpdateAt: number | null }>()
+  const backgroundModelCache = new Map<string, string | null>()
+
+  const readBackgroundMetas = (sessionId: string): StoredMessageMeta[] => {
+    const cached = backgroundMessageCache.get(sessionId)
+    if (cached) return cached
+    const backgroundMessageDir = getMessageDir(opts.storage.message, sessionId)
+    const recent = readRecentMessageMetas(backgroundMessageDir, 200, fsLike)
+    backgroundMessageCache.set(sessionId, recent)
+    return recent
+  }
+
+  const readBackgroundStats = (sessionId: string) => {
+    const cached = backgroundStatsCache.get(sessionId)
+    if (cached) return cached
+    const recent = readBackgroundMetas(sessionId)
+    const stats = deriveBackgroundSessionStats(opts.storage, recent, fsLike)
+    backgroundStatsCache.set(sessionId, stats)
+    return stats
+  }
+
+  const readBackgroundModel = (sessionId: string): string | null => {
+    if (backgroundModelCache.has(sessionId)) return backgroundModelCache.get(sessionId) ?? null
+    const recent = readBackgroundMetas(sessionId)
+    const model = pickLatestModelString(recent as unknown[])
+    backgroundModelCache.set(sessionId, model)
+    return model
+  }
 
   const rows: BackgroundTaskRow[] = []
 
@@ -225,7 +262,7 @@ export function deriveBackgroundTasks(opts: {
     const startedAt = meta.time?.created ?? null
     if (typeof startedAt !== "number") continue
 
-    const parts = readToolPartsForMessage(opts.storage, meta.id)
+    const parts = readToolPartsForMessage(opts.storage, meta.id, fsLike)
     for (const part of parts) {
       if (part.tool !== "delegate_task") continue
       if (!part.state || typeof part.state !== "object") continue
@@ -258,7 +295,7 @@ export function deriveBackgroundTasks(opts: {
         if (typeof resume === "string" && resume.trim() !== "") {
           // Check if resumed session exists (has readable messages dir)
           const resumeMessageDir = getMessageDir(opts.storage.message, resume.trim())
-          if (fs.existsSync(resumeMessageDir) && fs.readdirSync(resumeMessageDir).length > 0) {
+          if (fsLike.existsSync(resumeMessageDir) && fsLike.readdirSync(resumeMessageDir).length > 0) {
             backgroundSessionId = resume.trim()
           }
         }
@@ -283,8 +320,9 @@ export function deriveBackgroundTasks(opts: {
       }
 
       const stats = backgroundSessionId
-        ? deriveBackgroundSessionStats(opts.storage, backgroundSessionId)
+        ? readBackgroundStats(backgroundSessionId)
         : { toolCalls: 0, lastTool: null, lastUpdateAt: startedAt }
+      const lastModel = backgroundSessionId ? readBackgroundModel(backgroundSessionId) : null
 
       // Best-effort status: if background session exists and has any tool calls, treat as running unless idle.
       let status: BackgroundTaskRow["status"] = "unknown"
@@ -305,7 +343,8 @@ export function deriveBackgroundTasks(opts: {
         status,
         toolCalls: backgroundSessionId ? stats.toolCalls : null,
         lastTool: stats.lastTool,
-        timeline: formatTimeline(startedAt, timelineEndMs),
+        lastModel,
+        timeline: status === "unknown" ? "" : formatTimeline(startedAt, timelineEndMs),
         sessionId: backgroundSessionId,
       })
     }

package/src/ingest/model.ts

@@ -0,0 +1,79 @@
+type ModelParts = {
+  providerID?: string
+  modelID?: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
+function readString(value: unknown): string | null {
+  if (typeof value !== "string") return null
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
+function readModelParts(value: Record<string, unknown>): ModelParts {
+  const providerID =
+    readString(value.providerID) ??
+    readString(value.providerId) ??
+    readString(value.provider_id)
+  const modelID =
+    readString(value.modelID) ??
+    readString(value.modelId) ??
+    readString(value.model_id)
+
+  return { providerID: providerID ?? undefined, modelID: modelID ?? undefined }
+}
+
+export function extractModelString(meta: unknown): string | null {
+  if (!isRecord(meta)) return null
+
+  const direct = readModelParts(meta)
+  if (direct.providerID && direct.modelID) return `${direct.providerID}/${direct.modelID}`
+
+  const nested = meta.model
+  if (isRecord(nested)) {
+    const nestedParts = readModelParts(nested)
+    if (nestedParts.providerID && nestedParts.modelID) {
+      return `${nestedParts.providerID}/${nestedParts.modelID}`
+    }
+  }
+
+  return null
+}
+
+type ModelCandidate = {
+  created: number
+  id: string
+  role: string | null
+  model: string
+}
+
+export function pickLatestModelString(metas: Array<unknown>): string | null {
+  const candidates: ModelCandidate[] = []
+
+  for (const meta of metas) {
+    if (!isRecord(meta)) continue
+    const model = extractModelString(meta)
+    if (!model) continue
+
+    const created = typeof meta.time === "object" && meta.time !== null && typeof (meta.time as { created?: unknown }).created === "number"
+      ? (meta.time as { created: number }).created
+      : 0
+    const id = readString(meta.id) ?? ""
+    const role = readString(meta.role)
+
+    candidates.push({ created, id, role, model })
+  }
+
+  if (candidates.length === 0) return null
+
+  candidates.sort((a, b) => {
+    if (b.created !== a.created) return b.created - a.created
+    return b.id.localeCompare(a.id)
+  })
+
+  const assistant = candidates.find((candidate) => candidate.role === "assistant")
+  return assistant?.model ?? candidates[0]?.model ?? null
+}