@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.1

package/src/performance/dashboard.ts

@@ -0,0 +1,521 @@
+import { ResourceSources } from "@ericsanchezok/synergy-harness/observability/resource-sources"
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context"
+import { Cortex } from "@ericsanchezok/synergy-harness/cortex"
+import { Diagnostics } from "@ericsanchezok/synergy-harness/observability/diagnostics"
+import { ObservabilityIssues } from "@ericsanchezok/synergy-harness/observability/issues"
+import { ObservabilityStore } from "@ericsanchezok/synergy-harness/observability/store"
+import { SessionManager } from "@ericsanchezok/synergy-harness/session/manager"
+import { SessionMessageCache } from "@ericsanchezok/synergy-harness/session/message-cache"
+import { LLMTurnMemory } from "@ericsanchezok/synergy-harness/session/llm-memory"
+import { parseJson } from "@ericsanchezok/synergy-harness/util/json-parse"
+import { PerformanceProjection } from "./projection"
+import { PerformanceSchema } from "./schema"
+import { AgentTurn } from "@ericsanchezok/synergy-harness/session/agent-turn"
+import { readRuntimeStats } from "@ericsanchezok/synergy-harness/lifecycle"
+import { PolicyWorker } from "@ericsanchezok/synergy-harness/enforcement/policy-worker"
+import { ProcessRegistry } from "@ericsanchezok/synergy-harness/process/registry"
+import { SessionMemoryPressure } from "@ericsanchezok/synergy-harness/session/memory-pressure"
+
+export namespace PerformanceDashboard {
+  type MetricRow = ObservabilityStore.StoredMetric
+
+  const SUMMARY_CACHE_MS = 1000
+  const runtimeState = RuntimeContext.state(() => ({
+    cached: undefined as
+      | {
+          key: string
+          version: number
+          pending: boolean
+          at: number
+          value: Promise<PerformanceSchema.DashboardSummary>
+        }
+      | undefined,
+    labelsCache: new WeakMap<object, Record<string, unknown>>(),
+  }))
+
+  // Ranked and latest detail can reuse the same row across several projections.
+  function metricLabels(row: object): Record<string, unknown> {
+    const instanceState = runtimeState()
+
+    const cachedLabels = instanceState.labelsCache.get(row)
+    if (cachedLabels) return cachedLabels
+    const labels = parseJson((row as { labels_json: string }).labels_json)
+    instanceState.labelsCache.set(row, labels)
+    return labels
+  }
+
+  export function summary(
+    input: { windowMs?: number; scopeID?: string } = {},
+  ): Promise<PerformanceSchema.DashboardSummary> {
+    const instanceState = runtimeState()
+
+    const key = `${input.windowMs ?? 300_000}:${input.scopeID ?? ""}`
+    const version = ObservabilityStore.dataVersion()
+    const now = Date.now()
+    if (
+      instanceState.cached?.key === key &&
+      (instanceState.cached.pending ||
+        (instanceState.cached.version === version && now - instanceState.cached.at < SUMMARY_CACHE_MS))
+    )
+      return instanceState.cached.value
+    const value = computeSummary(input)
+    const wrapped = value
+      .then((result) => {
+        if (instanceState.cached?.value === wrapped) {
+          instanceState.cached.pending = false
+          instanceState.cached.at = Date.now()
+        }
+        return result
+      })
+      .catch((error) => {
+        const instanceState = runtimeState()
+
+        if (instanceState.cached?.value === wrapped) instanceState.cached = undefined
+        throw error
+      })
+    instanceState.cached = { key, version, pending: true, at: now, value: wrapped }
+    return wrapped
+  }
+  async function computeSummary(
+    input: { windowMs?: number; scopeID?: string } = {},
+  ): Promise<PerformanceSchema.DashboardSummary> {
+    const windowMs = Math.max(1000, Math.min(input.windowMs ?? 300_000, 86_400_000))
+    // Storage uses an exclusive upper bound; include observations in the current millisecond.
+    const until = Date.now() + 1
+    const since = until - windowMs
+    const filter = { since, until, scopeID: input.scopeID }
+    const aggregate = async (name: string) =>
+      (
+        await ObservabilityStore.queryMetricBuckets({
+          since,
+          until,
+          scopeID: input.scopeID,
+          names: [name],
+          bucketMs: windowMs + 1,
+        })
+      )[0]
+    const [requests, turnSummary, resourceSummary, counts, toolSums, activeSessions] = await Promise.all([
+      aggregate("http.request.duration"),
+      aggregate("session.turn.duration"),
+      aggregate("frontend.resource.duration"),
+      ObservabilityStore.queryMetricCounts(filter),
+      ObservabilityStore.queryMetricSums({ ...filter, names: ["tool.execution.count", "tool.execution.error"] }),
+      ObservabilityStore.countMetricSessions({ ...filter, since: Math.max(since, until - 300_000) }),
+    ])
+    const highlightNames = counts
+      .filter(
+        (row) =>
+          (row.module === "llm" && row.name.endsWith(".duration")) ||
+          [
+            "http.request.duration",
+            "session.turn.duration",
+            "tool.execution.duration",
+            "storage.operation.duration",
+            "library.operation.duration",
+            "frontend.resource.duration",
+            "frontend.long_task.duration",
+            "frontend.web_vital",
+            "service.memory.current",
+            "service.memory.working_set",
+            "service.memory.reclaimable",
+            "service.memory.peak",
+          ].includes(row.name),
+      )
+      .map((row) => row.name)
+    const metrics = highlightNames.length
+      ? await ObservabilityStore.queryMetricHighlights({ ...filter, names: [...new Set(highlightNames)] })
+      : []
+    const count = (name: string) => counts.filter((row) => row.name === name).reduce((sum, row) => sum + row.count, 0)
+    const serverFilter = { role: "server", until, limit: 1 } as const
+    const resources = ObservabilityStore.resourceSince(since, { ...serverFilter, newestFirst: true })[0]
+    const serverBaseline = ObservabilityStore.resourceSince(since, serverFilter)[0]
+    const currentChildRows = resources
+      ? ObservabilityStore.resourceSince(resources.time, {
+          role: "tool",
+          until: resources.time + 1,
+          limit: 50_000,
+        })
+      : []
+    const [serverResources, childResources] = await Promise.all([
+      ObservabilityStore.resourceSummary({ since, until, role: "server" }),
+      resources
+        ? ObservabilityStore.resourceSummary({ since: resources.time, until: resources.time + 1, role: "tool" })
+        : undefined,
+    ])
+    const childProcesses = rankChildProcesses(currentChildRows)
+    const issueCounts = ObservabilityStore.countIssues({ status: "open", scopeID: input.scopeID, since })
+    const issues = ObservabilityIssues.list({
+      status: "open",
+      scopeID: input.scopeID,
+      since,
+      limit: 20,
+    }).map(PerformanceProjection.issue)
+    const diagnostics = await Diagnostics.summary().catch(() => undefined)
+    const runtimeStats = SessionManager.runtimeStats()
+    const agentWorkers = AgentTurn.stats()
+    const policyWorkers = PolicyWorker.stats()
+    const { toolTasks } = readRuntimeStats()
+    const contributedResources = await ResourceSources.read()
+    const localProcesses = await ProcessRegistry.resourceStats()
+    const controlPlane = SessionMemoryPressure.stats()
+    const messageCacheStats = SessionMessageCache.stats()
+    const llmTurnStats = LLMTurnMemory.stats()
+    const activeLLMTurns = LLMTurnMemory.activeSnapshot(20)
+    const cortexTasks = Cortex.list()
+    const cortexStats = {
+      totalCount: cortexTasks.length,
+      byStatus: {
+        queued: cortexTasks.filter((task) => task.status === "queued").length,
+        running: cortexTasks.filter((task) => task.status === "running").length,
+        completed: cortexTasks.filter((task) => task.status === "completed").length,
+        error: cortexTasks.filter((task) => task.status === "error").length,
+        cancelled: cortexTasks.filter((task) => task.status === "cancelled").length,
+        interrupted: cortexTasks.filter((task) => task.status === "interrupted").length,
+      },
+      retainedPromptChars: cortexTasks.reduce((sum, task) => sum + task.prompt.length, 0),
+      retainedOutputChars: cortexTasks.reduce((sum, task) => {
+        if (!task.output) return sum
+        if (task.output.mode === "summary" || task.output.mode === "final_response")
+          return sum + task.output.value.length
+        try {
+          return sum + JSON.stringify(task.output.value).length
+        } catch {
+          return sum
+        }
+      }, 0),
+      retainedErrorChars: cortexTasks.reduce((sum, task) => sum + (task.error?.length ?? 0), 0),
+      retainedProgressToolCount: cortexTasks.reduce((sum, task) => sum + (task.progress?.recentTools?.length ?? 0), 0),
+    }
+    const http = metrics.filter((row) => row.name === "http.request.duration")
+    const turns = metrics.filter((row) => row.name === "session.turn.duration")
+    const llm = metrics.filter((row) => row.module === "llm" && row.name.endsWith(".duration"))
+    const tools = metrics.filter((row) => row.name === "tool.execution.duration")
+    const toolFailures = rankToolFailures(toolSums)
+    const storage = metrics.filter((row) => row.name === "storage.operation.duration")
+    const library = metrics.filter((row) => row.name === "library.operation.duration")
+    const frontendResources = metrics.filter((row) => row.name === "frontend.resource.duration")
+    const frontendLongTasks = metrics.filter((row) => row.name === "frontend.long_task.duration")
+    const frontendVital = (name: string) =>
+      metrics.find((row) => row.name === "frontend.web_vital" && metricLabels(row).name === name)?.value
+    const criticalIssueCount = issueCounts.critical
+    const score = Math.max(0, 100 - criticalIssueCount * 40 - issueCounts.error * 20 - issueCounts.warning * 8)
+    const status = criticalIssueCount > 0 ? "critical" : issueCounts.total > 0 ? "degraded" : "healthy"
+    const serverPeakBytes = serverResources?.peakRssBytes ?? undefined
+    const currentServerBytes = resources?.memory_rss_bytes ?? undefined
+    const serverBaselineBytes = serverBaseline?.memory_rss_bytes ?? undefined
+    const latestMetric = (name: string) => metrics.find((row) => row.name === name)?.value
+    const owners: PerformanceSchema.DashboardSummary["resources"]["owners"] = [
+      {
+        owner: "control_plane",
+        processCount: 1,
+        measuredProcessCount: currentServerBytes === undefined ? 0 : 1,
+        currentBytes: currentServerBytes,
+        peakBytes: serverPeakBytes ?? currentServerBytes,
+        baselineBytes: serverBaselineBytes,
+        retainedBytes:
+          currentServerBytes === undefined || serverBaselineBytes === undefined
+            ? undefined
+            : Math.max(0, currentServerBytes - serverBaselineBytes),
+        heapUsedBytes: resources?.memory_heap_used_bytes ?? undefined,
+        externalBytes: resources?.memory_external_bytes ?? undefined,
+        arrayBuffersBytes: resources?.memory_array_buffers_bytes ?? undefined,
+        source: "process_api",
+        completeness: currentServerBytes === undefined ? "unavailable" : "full",
+        attributes: {
+          pressure: controlPlane.lastAssessment?.pressure ?? "unknown",
+          processPressure: controlPlane.lastAssessment?.processPressure ?? "unknown",
+          servicePressure: controlPlane.lastAssessment?.servicePressure ?? "unknown",
+        },
+        lastRecovery: controlPlane.lastRecovery,
+      },
+      {
+        owner: "agent",
+        processCount: agentWorkers.workers,
+        measuredProcessCount: agentWorkers.measuredWorkers,
+        currentBytes: agentWorkers.rssBytes,
+        peakBytes: agentWorkers.peakBytes,
+        baselineBytes: agentWorkers.baselineBytes,
+        retainedBytes: agentWorkers.retainedBytes,
+        heapUsedBytes: agentWorkers.heapUsedBytes,
+        externalBytes: agentWorkers.externalBytes,
+        arrayBuffersBytes: agentWorkers.arrayBuffersBytes,
+        source: "worker_ipc",
+        completeness:
+          agentWorkers.workers === 0 || agentWorkers.measuredWorkers === agentWorkers.workers ? "full" : "partial",
+        attributes: { active: agentWorkers.active, queued: agentWorkers.queued },
+        lastRecovery: agentWorkers.lastRecovery,
+      },
+      {
+        owner: "policy",
+        processCount: policyWorkers.workers,
+        measuredProcessCount: policyWorkers.measuredWorkers,
+        currentBytes: policyWorkers.rssBytes,
+        peakBytes: policyWorkers.peakBytes,
+        baselineBytes: policyWorkers.baselineBytes,
+        retainedBytes: policyWorkers.retainedBytes,
+        heapUsedBytes: policyWorkers.heapUsedBytes,
+        externalBytes: policyWorkers.externalBytes,
+        arrayBuffersBytes: policyWorkers.arrayBuffersBytes,
+        source: "worker_ipc",
+        completeness:
+          policyWorkers.workers === 0 || policyWorkers.measuredWorkers === policyWorkers.workers ? "full" : "partial",
+        attributes: { active: policyWorkers.active, queued: policyWorkers.queued },
+        lastRecovery: policyWorkers.lastRecovery,
+      },
+      ...contributedResources,
+      {
+        owner: "local_process",
+        ...localProcesses,
+        source: "process_registry",
+        completeness:
+          localProcesses.processCount === 0 || localProcesses.measuredProcessCount === localProcesses.processCount
+            ? "full"
+            : "partial",
+        attributes: {
+          stdioOpen: localProcesses.stdio.open,
+          stdioDraining: localProcesses.stdio.draining,
+          stdioClosed: localProcesses.stdio.closed,
+          timedOut: localProcesses.stdio.timedOut,
+          drainTimedOut: localProcesses.stdio.drainTimedOut,
+          descendantPipeGraceMs: localProcesses.stdio.descendantPipeGraceMs,
+        },
+      },
+    ]
+    return PerformanceSchema.DashboardSummary.parse({
+      generatedAt: new Date().toISOString(),
+      windowMs,
+      health: { status, score, openIssueCount: issueCounts.total, criticalIssueCount },
+      backend: {
+        requestCount: requests?.count ?? 0,
+        errorRate: requests ? requests.errors / requests.count : 0,
+        p50RequestMs: requests?.p50,
+        p95RequestMs: requests?.p95,
+        p99RequestMs: requests?.p99,
+        activeSessions,
+        pendingSessions: diagnostics?.sessions.paused.length ?? 0,
+      },
+      resources: {
+        rssBytes: resources?.memory_rss_bytes ?? undefined,
+        heapUsedBytes: resources?.memory_heap_used_bytes ?? undefined,
+        heapTotalBytes: resources?.memory_heap_total_bytes ?? undefined,
+        externalBytes: resources?.memory_external_bytes ?? undefined,
+        arrayBuffersBytes: resources?.memory_array_buffers_bytes ?? undefined,
+        cpuUtilizationRatio: resources?.cpu_utilization_ratio ?? undefined,
+        eventLoopLagP95Ms: serverResources?.eventLoopLagP95Ms ?? undefined,
+        appReadBytes: resources?.app_read_bytes ?? undefined,
+        appWrittenBytes: resources?.app_written_bytes ?? undefined,
+        appReadOps: resources?.app_read_ops ?? undefined,
+        appWriteOps: resources?.app_write_ops ?? undefined,
+        childProcessCount: childResources?.count ?? 0,
+        measuredChildProcessCount: childResources?.measuredCount ?? 0,
+        serviceMemory:
+          resources?.service_memory_source && resources.service_memory_completeness
+            ? {
+                rssBytes: resources.service_memory_rss_bytes ?? undefined,
+                currentBytes: latestMetric("service.memory.current") ?? resources.service_memory_rss_bytes ?? undefined,
+                workingSetBytes: latestMetric("service.memory.working_set"),
+                reclaimableBytes: latestMetric("service.memory.reclaimable"),
+                peakBytes: latestMetric("service.memory.peak"),
+                source: resources.service_memory_source,
+                completeness: resources.service_memory_completeness,
+              }
+            : undefined,
+        childProcessRssBytes: childResources?.rssBytes ?? 0,
+        owners,
+      },
+      sessions: {
+        turnCount: turnSummary?.count ?? 0,
+        p95TurnMs: turnSummary?.p95,
+        llmCallCount: counts
+          .filter((row) => row.module === "llm" && row.name.endsWith(".duration"))
+          .reduce((sum, row) => sum + row.count, 0),
+        toolCallCount: count("tool.execution.duration"),
+      },
+      frontend: {
+        inpMs: frontendVital("INP"),
+        lcpMs: frontendVital("LCP"),
+        cls: frontendVital("CLS"),
+        fcpMs: frontendVital("FCP"),
+        ttfbMs: frontendVital("TTFB"),
+        longTaskCount: count("frontend.long_task.duration"),
+        resourceP95Ms: resourceSummary?.p95,
+      },
+      runtime: {
+        alive:
+          diagnostics?.lock?.inspection && typeof diagnostics.lock.inspection === "object"
+            ? (diagnostics.lock.inspection as { alive?: boolean }).alive
+            : undefined,
+        healthy:
+          diagnostics?.lock?.inspection && typeof diagnostics.lock.inspection === "object"
+            ? (diagnostics.lock.inspection as { healthy?: boolean }).healthy
+            : undefined,
+        pid:
+          diagnostics?.lock?.lock && typeof diagnostics.lock.lock === "object"
+            ? (diagnostics.lock.lock as { pid?: number }).pid
+            : undefined,
+        mode:
+          diagnostics?.lock?.lock && typeof diagnostics.lock.lock === "object"
+            ? (diagnostics.lock.lock as { mode?: string }).mode
+            : undefined,
+        mirrorFiles: diagnostics?.traces.files.length ?? 0,
+        traceFiles: diagnostics?.traces.files.length ?? 0,
+        recentErrors: diagnostics?.traces.recentErrors.length ?? 0,
+        pendingSessions: diagnostics?.sessions.paused.length ?? 0,
+        sessionRuntimes: runtimeStats,
+        execution: {
+          agentWorkers,
+          policyWorkers,
+          toolTasks,
+        },
+        messageCache: {
+          totalBytes: messageCacheStats.totalBytes,
+          activeCount: messageCacheStats.activeCount,
+          entryCount: messageCacheStats.entryCount,
+          hits: messageCacheStats.hits,
+          misses: messageCacheStats.misses,
+          evictions: messageCacheStats.evictions,
+          protectedOverbudget: messageCacheStats.protectedOverbudget,
+          entries: messageCacheStats.entries.map((entry) => ({ estimatedBytes: entry.estimatedBytes })),
+          truncatedEntryCount: messageCacheStats.truncatedEntryCount,
+        },
+        llmTurns: {
+          ...llmTurnStats,
+          turns: activeLLMTurns.map((turn) => ({
+            ageMs: turn.ageMs,
+            streamActive: turn.streamActive,
+            providerID: turn.providerID,
+            modelID: turn.modelID,
+            historyBeforeBytes: turn.historyBeforeBytes,
+            historyAfterBytes: turn.historyAfterBytes,
+            requestBytes: turn.requestBytes,
+            toolSchemaBytes: turn.toolSchemaBytes,
+            outputChars: turn.outputChars,
+            toolRawChars: turn.toolRawChars,
+          })),
+        },
+        cortexTasks: {
+          totalCount: cortexStats.totalCount,
+          queuedCount: cortexStats.byStatus.queued,
+          runningCount: cortexStats.byStatus.running,
+          completedCount: cortexStats.byStatus.completed,
+          errorCount: cortexStats.byStatus.error,
+          cancelledCount: cortexStats.byStatus.cancelled,
+          interruptedCount: cortexStats.byStatus.interrupted,
+          retainedPromptChars: cortexStats.retainedPromptChars,
+          retainedOutputChars: cortexStats.retainedOutputChars,
+          retainedErrorChars: cortexStats.retainedErrorChars,
+          retainedProgressToolCount: cortexStats.retainedProgressToolCount,
+        },
+      },
+      top: {
+        slowRoutes: rank(http, "path"),
+        slowSessions: rank(turns, "session_id"),
+        slowTools: rank(tools, "tool"),
+        toolFailures,
+        slowProviders: rank(llm, "providerID", "provider", "modelID", "model"),
+        slowStorage: rank(storage, "operation"),
+        slowLibrary: rank(library, "operation"),
+        childProcesses,
+        slowFrontend: rank(
+          [...frontendResources, ...frontendLongTasks],
+          "routeName",
+          "pathTemplate",
+          "route",
+          "name",
+          "attribution",
+        ),
+      },
+      issues,
+    })
+  }
+
+  function rank(rows: MetricRow[], ...labelKeys: string[]): PerformanceSchema.RankedItem[] {
+    return [...rows]
+      .sort((a, b) => b.value - a.value)
+      .slice(0, 5)
+      .map((row, index) => {
+        const label = String(firstLabel(metricLabels(row), labelKeys) ?? row.tool ?? row.session_id ?? row.name)
+        return {
+          id: `${row.metric_id}-${index}`,
+          label,
+          module: row.module as PerformanceSchema.Module,
+          value: row.value,
+          unit: row.unit as PerformanceSchema.Unit,
+          traceId: row.trace_id ?? undefined,
+          sessionID: row.session_id ?? undefined,
+          tool: row.tool ?? undefined,
+        }
+      })
+  }
+
+  function rankToolFailures(
+    rows: Array<Pick<MetricRow, "name" | "tool" | "labels_json" | "value">>,
+  ): PerformanceSchema.ToolFailureItem[] {
+    const tools = new Map<string, { callCount: number; errorCount: number; categories: Map<string, number> }>()
+    for (const row of rows) {
+      if (row.name !== "tool.execution.count" && row.name !== "tool.execution.error") continue
+      const tool = row.tool ?? stringLabel(metricLabels(row).tool)
+      if (!tool) continue
+      const entry = tools.get(tool) ?? { callCount: 0, errorCount: 0, categories: new Map<string, number>() }
+      if (row.name === "tool.execution.count") {
+        entry.callCount += row.value
+      } else {
+        entry.errorCount += row.value
+        const errorClass = stringLabel(metricLabels(row).errorName) ?? "UnknownError"
+        entry.categories.set(errorClass, (entry.categories.get(errorClass) ?? 0) + row.value)
+      }
+      tools.set(tool, entry)
+    }
+    return Array.from(tools, ([tool, entry]) => ({
+      tool,
+      callCount: entry.callCount,
+      errorCount: entry.errorCount,
+      errorRate: entry.errorCount / Math.max(entry.callCount, entry.errorCount, 1),
+      categories: Array.from(entry.categories, ([errorClass, count]) => ({ errorClass, count }))
+        .sort((a, b) => b.count - a.count || a.errorClass.localeCompare(b.errorClass))
+        .slice(0, 3),
+    }))
+      .filter((entry) => entry.errorCount > 0)
+      .sort((a, b) => b.errorCount - a.errorCount || b.errorRate - a.errorRate || a.tool.localeCompare(b.tool))
+      .slice(0, 5)
+  }
+
+  function stringLabel(value: unknown) {
+    return typeof value === "string" && value.length > 0 ? value : undefined
+  }
+
+  function rankChildProcesses(rows: ObservabilityStore.StoredResource[]): PerformanceSchema.RankedItem[] {
+    const latest = new Map<string, ObservabilityStore.StoredResource>()
+    for (const row of rows) {
+      if (!row.process_role?.startsWith("tool")) continue
+      if (row.memory_rss_bytes === undefined || row.memory_rss_bytes === null) continue
+      const id = row.process_id ?? (row.pid === undefined || row.pid === null ? undefined : `pid:${row.pid}`)
+      if (!id) continue
+      const existing = latest.get(id)
+      if (!existing || row.time > existing.time) latest.set(id, row)
+    }
+    return Array.from(latest.values())
+      .sort((a, b) => (b.memory_rss_bytes ?? 0) - (a.memory_rss_bytes ?? 0))
+      .slice(0, 5)
+      .map((row, index) => {
+        const labels = metricLabels(row)
+        return {
+          id: `${row.sample_id}-${index}`,
+          label: String(labels.command ?? labels.description ?? row.process_id ?? row.pid ?? "tool child process"),
+          module: "process" as const,
+          value: row.memory_rss_bytes ?? 0,
+          unit: "bytes" as const,
+          processId: row.process_id ?? undefined,
+          pid: row.pid ?? undefined,
+          status: row.process_role ?? undefined,
+        }
+      })
+  }
+
+  function firstLabel(labels: Record<string, unknown>, keys: string[]) {
+    for (const key of keys) {
+      const value = labels[key]
+      if (value !== undefined && value !== null && value !== "") return value
+    }
+  }
+}

package/src/performance/error.ts

@@ -0,0 +1,32 @@
+export class PerformanceError extends Error {
+  constructor(
+    readonly code: PerformanceError.Code,
+    message: string,
+    readonly status: number,
+    readonly data: Record<string, unknown> = {},
+  ) {
+    super(message)
+    this.name = "PerformanceError"
+  }
+
+  toResponse() {
+    return { code: this.code, message: this.message, ...this.data }
+  }
+}
+
+export namespace PerformanceError {
+  export type Code =
+    | "PERF_INVALID_QUERY"
+    | "PERF_TOO_MANY_BUCKETS"
+    | "PERF_FORBIDDEN"
+    | "PERF_RATE_LIMITED"
+    | "PERF_OBSERVABILITY_UNAVAILABLE"
+    | "PERF_TRACE_NOT_FOUND"
+    | "PERF_INVALID_METRIC_BATCH"
+    | "PERF_CONFIG_RESTART_REQUIRED"
+    | "PERF_CONFIG_CONFLICT"
+    | "PERF_STORAGE_UNAVAILABLE"
+    | "PERF_SPAN_CONFLICT"
+    | "PERF_ANALYSIS_NOT_FOUND"
+    | "PERF_ANALYSIS_UNAVAILABLE"
+}

package/src/performance/index.ts

@@ -0,0 +1,6 @@
+export { PerformanceDashboard } from "./dashboard"
+export { PerformanceError } from "./error"
+export { PerformanceInflight } from "./inflight"
+export { PerformanceSchema } from "./schema"
+export { PerformanceTimeline } from "./timeline"
+export { PerformanceTraceDetail } from "./trace-detail"

package/src/performance/inflight.ts

@@ -0,0 +1,46 @@
+import { ObservabilityStore } from "@ericsanchezok/synergy-harness/observability/store"
+import { PerformanceSchema } from "./schema"
+import { parseJson } from "@ericsanchezok/synergy-harness/util/json-parse"
+
+export namespace PerformanceInflight {
+  export function get(
+    input: { scopeID?: string; sessionID?: string; staleMs?: number; limit?: number } = {},
+  ): PerformanceSchema.Inflight {
+    const spans = ObservabilityStore.queryInflight(input).map((row) =>
+      PerformanceSchema.InflightSpan.parse({
+        traceId: row.trace_id,
+        correlationId: row.correlation_id ?? undefined,
+        spanId: row.span_id,
+        parentSpanId: row.parent_span_id ?? undefined,
+        kind: row.kind,
+        name: row.name,
+        module: row.module,
+        source: row.source,
+        startTime: row.start_time,
+        endTime: row.end_time ?? undefined,
+        durationMs: row.duration_ms ?? undefined,
+        status: row.status,
+        lastActivityTime: row.last_activity_time ?? undefined,
+        heartbeatTime: row.heartbeat_time ?? undefined,
+        heartbeatCount: row.heartbeat_count ?? undefined,
+        stalled: row.stalled ? true : undefined,
+        errorCode: row.error_code ?? undefined,
+        errorMessage: row.error_message ?? undefined,
+        scopeID: row.scope_id ?? undefined,
+        sessionID: row.session_id ?? undefined,
+        messageID: row.message_id ?? undefined,
+        callID: row.call_id ?? undefined,
+        rid: row.rid ?? undefined,
+        processId: row.process_id ?? undefined,
+        pid: row.pid ?? undefined,
+        tool: row.tool ?? undefined,
+        attributes: parseJson(row.attributes_json),
+        ageMs: row.age_ms,
+        idleMs: row.idle_ms,
+        stale: row.stale,
+        activeSince: row.last_activity_time ?? row.start_time,
+      }),
+    )
+    return PerformanceSchema.Inflight.parse({ generatedAt: new Date().toISOString(), spans })
+  }
+}