helixevo 0.2.40 → 0.3.0

package/dashboard/lib/data.ts

@@ -18,10 +18,16 @@ function readJsonl<T>(filename: string): T[] {
 
 // ─── Types ──────────────────────────────────────────────────────
 
+export type CognitiveRole = 'generalist' | 'specialist' | 'hybrid'
+export type StabilityState = 'stable' | 'adaptive' | 'experimental'
+export type PlasticityState = 'consolidated' | 'volatile' | 'candidate'
+
 export interface SkillNode {
   id: string; name: string; layer: string; score: number
   generation: number; status: string; tags: string[]
   failureCount: number; lastEvolved: string; project?: string
+  cognitiveRole?: CognitiveRole; stabilityState?: StabilityState; plasticityState?: PlasticityState
+  capabilities?: string[]; lineageId?: string
 }
 
 export interface SkillEdge {
@@ -31,7 +37,7 @@ export interface SkillEdge {
 }
 
 export interface SkillGraph {
-  updated: string; nodes: SkillNode[]; edges: SkillEdge[]
+  updated: string; ontologyVersion?: string; nodes: SkillNode[]; edges: SkillEdge[]
   clusters: { id: string; name: string; skills: string[]; cohesion: number }[]
 }
 
@@ -39,6 +45,7 @@ export interface Failure {
   id: string; sessionId: string; timestamp: string; project: string | null
   userRequest: string; agentAction: string; correction: string
   correctionType: string; skillsActive: string[]; resolved?: boolean
+  pressureSignals?: string[]; capabilityGaps?: string[]; activationTraceId?: string
 }
 
 export interface Frontier {
@@ -71,6 +78,159 @@ export interface CanaryEntry {
   skillSlug: string; version: string; deployedAt: string; expiresAt: string
 }
 
+export type ArtifactProvenance = 'native-evolution' | 'derived-history'
+export type ActivationProvenance = 'capture-derived' | 'project-analysis' | 'derived-failure'
+export type PressureProvenance = 'failure-native' | 'project-analysis-native' | 'failure-derived' | 'profile-gap-derived'
+
+export interface EvidenceArtifact {
+  id: string
+  createdAt: string
+  artifactType: 'evolution' | 'replay' | 'regression' | 'canary' | 'project-analysis' | 'ontology-review'
+  provenance: ArtifactProvenance
+  title: string
+  summary: string
+  sourceId?: string
+  iterationId?: string
+  proposalId?: string
+  projectId?: string
+  targetSkill?: string
+  operation?: string
+  outcome?: 'accepted' | 'rejected' | 'canary'
+  clusterType?: string
+  trigger?: string
+  judgeScores?: {
+    taskCompletion: number
+    correctionAlignment: number
+    sideEffectCheck: number
+  }
+  regression?: {
+    total: number
+    passed: number
+    passRate: number
+  }
+  metrics?: Record<string, number>
+}
+
+export interface ActivationTrace {
+  id: string
+  timestamp: string
+  provenance: ActivationProvenance
+  sourceId: string
+  projectId?: string
+  projectPath?: string
+  sessionId?: string
+  activatedSkillIds: string[]
+  relevantSkillIds?: string[]
+  reasonSummary: string
+  contextSummary?: string
+  gapAreas?: string[]
+  recommendations?: string[]
+  relatedFailureId?: string
+  traceVersion?: string
+}
+
+export interface PressureSignal {
+  id: string
+  kind: string
+  provenance: PressureProvenance
+  sourceType: 'failure' | 'correction' | 'replay' | 'regression' | 'project-analysis' | 'research' | 'manual'
+  sourceId: string
+  projectId?: string
+  projectPath?: string
+  detectedAt: string
+  severity: number
+  priority?: 'high' | 'medium' | 'low'
+  capability?: string
+  region?: string
+  description?: string
+  suggestedAction?: 'research' | 'specialize' | 'create'
+  relatedFailureId?: string
+  relatedActivationTraceId?: string
+  skillIds?: string[]
+  status?: 'open' | 'addressed'
+}
+
+export interface ProjectPressureSummary {
+  projectId: string
+  totalSignals: number
+  nativeSignals: number
+  derivedSignals: number
+  highPrioritySignals: number
+  topCapabilities: string[]
+}
+
+export interface CoEvolutionDashboardSummary {
+  pressureSignals: {
+    total: number
+    native: number
+    derived: number
+  }
+  topProjects: ProjectPressureSummary[]
+  rolePressure: Record<CognitiveRole, number>
+  crossProjectGapAreas: { area: string; projects: string[]; count: number }[]
+  activeRecommendations: { action: 'research' | 'specialize' | 'create'; count: number }[]
+}
+
+export interface OntologyDashboardSummary {
+  specVersion: string
+  source: 'graph' | 'compat-derived'
+  skillRoles: Record<CognitiveRole, number>
+  stabilityStates: Record<StabilityState, number>
+  plasticityStates: Record<PlasticityState, number>
+  enrichedSkillNodes: number
+  relationFamiliesObserved: number
+  mutationOperationsObserved: number
+  observedMutationActions: string[]
+  evidenceBackedProposals: number
+  artifacts: {
+    total: number
+    native: number
+    derived: number
+  }
+  activationTraces: {
+    total: number
+    native: number
+    derived: number
+  }
+  pressureSignals: {
+    total: number
+    native: number
+    derived: number
+  }
+  annotatedFailures: {
+    pressureSignals: number
+    capabilityGaps: number
+    activationTraces: number
+  }
+}
+
+const DASHBOARD_ONTOLOGY_SPEC_VERSION = '0.1.0'
+
+function emptyCounts<T extends string>(values: readonly T[]): Record<T, number> {
+  return Object.fromEntries(values.map((value) => [value, 0])) as Record<T, number>
+}
+
+function inferCognitiveRole(node: SkillNode): CognitiveRole {
+  if (node.cognitiveRole) return node.cognitiveRole
+  if (node.layer === 'project' || Boolean(node.project)) return 'specialist'
+  if (node.generation > 0 && node.failureCount > 0) return 'hybrid'
+  return 'generalist'
+}
+
+function inferStabilityState(node: SkillNode): StabilityState {
+  if (node.stabilityState) return node.stabilityState
+  if (node.status === 'canary' || node.score < 0.55) return 'experimental'
+  if (inferCognitiveRole(node) === 'generalist' && node.generation > 0 && node.score >= 0.7) return 'stable'
+  return 'adaptive'
+}
+
+function inferPlasticityState(node: SkillNode): PlasticityState {
+  if (node.plasticityState) return node.plasticityState
+  if (node.status === 'canary' || node.generation === 0) return 'candidate'
+  if (node.generation >= 2 || node.score >= 0.8) return 'consolidated'
+  return 'volatile'
+}
+
 // ─── Loaders ────────────────────────────────────────────────────
 
 export function loadGraph(): SkillGraph {
@@ -109,6 +269,218 @@ export function loadSkillContent(slug: string): string {
   return readFileSync(path, 'utf-8')
 }
 
+function buildDerivedEvolutionArtifact(iteration: Iteration, proposal: Proposal): EvidenceArtifact {
+  return {
+    id: `artifact_derived_${iteration.id}_${proposal.id}`,
+    createdAt: iteration.timestamp,
+    artifactType: 'evolution',
+    provenance: 'derived-history',
+    sourceId: iteration.id,
+    iterationId: iteration.id,
+    proposalId: proposal.id,
+    title: `${proposal.targetSkill} · ${proposal.action}`,
+    summary: proposal.description,
+    targetSkill: proposal.targetSkill,
+    operation: proposal.action,
+    outcome: proposal.outcome as 'accepted' | 'rejected' | 'canary',
+    trigger: iteration.trigger,
+    judgeScores: {
+      taskCompletion: proposal.judges.taskCompletion.score,
+      correctionAlignment: proposal.judges.correctionAlignment.score,
+      sideEffectCheck: proposal.judges.sideEffectCheck.score,
+    },
+    regression: proposal.regressionResult,
+    metrics: {
+      regressionPassRate: proposal.regressionResult.passRate,
+      proposalConsensus: proposal.consensus ? 1 : 0,
+    },
+  }
+}
+
+function buildDerivedActivationTraceFromFailure(failure: Failure): ActivationTrace {
+  return {
+    id: failure.activationTraceId ?? `activation_derived_${failure.id}`,
+    timestamp: failure.timestamp,
+    provenance: 'derived-failure',
+    sourceId: failure.id,
+    projectId: failure.project ?? undefined,
+    sessionId: failure.sessionId,
+    activatedSkillIds: failure.skillsActive,
+    relevantSkillIds: failure.skillsActive,
+    reasonSummary: `${failure.correctionType} correction captured from failure`,
+    contextSummary: failure.correction,
+    relatedFailureId: failure.id,
+    traceVersion: '0.1.0',
+  }
+}
+
+export function loadEvolutionArtifacts(): EvidenceArtifact[] {
+  const nativeArtifacts = readJsonl<EvidenceArtifact>('evolution-artifacts.jsonl')
+  const history = loadHistory()
+  const derivedArtifacts = history.iterations.flatMap((iteration) => iteration.proposals.map((proposal) => buildDerivedEvolutionArtifact(iteration, proposal)))
+  const nativeProposalIds = new Set(nativeArtifacts.map((artifact) => artifact.proposalId).filter(Boolean))
+  return [
+    ...nativeArtifacts,
+    ...derivedArtifacts.filter((artifact) => !artifact.proposalId || !nativeProposalIds.has(artifact.proposalId)),
+  ].sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+}
+
+export function loadActivationTraces(): ActivationTrace[] {
+  const nativeTraces = readJsonl<ActivationTrace>('activation-traces.jsonl')
+  const failures = loadFailures()
+  const derivedTraces = failures
+    .filter((failure) => failure.skillsActive.length > 0)
+    .map(buildDerivedActivationTraceFromFailure)
+  const nativeSourceIds = new Set(nativeTraces.map((trace) => trace.sourceId))
+  return [
+    ...nativeTraces,
+    ...derivedTraces.filter((trace) => !nativeSourceIds.has(trace.sourceId)),
+  ].sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+}
+
+function inferFailurePressurePriority(failure: Failure): 'high' | 'medium' | 'low' {
+  if (failure.correctionType === 'manual_edit' || failure.correctionType === 'mode_switch') return 'high'
+  if (failure.skillsActive.length === 0) return 'high'
+  if (failure.correctionType === 'retry') return 'medium'
+  return 'low'
+}
+
+function inferFailurePressureSeverity(failure: Failure): number {
+  const base = failure.correctionType === 'manual_edit' ? 0.95
+    : failure.correctionType === 'mode_switch' ? 0.9
+      : failure.correctionType === 'retry' ? 0.72
+        : 0.65
+  return failure.skillsActive.length === 0 ? Math.min(1, base + 0.08) : base
+}
+
+function buildDerivedPressureSignalFromFailure(failure: Failure): PressureSignal {
+  return {
+    id: `pressure_derived_${failure.id}`,
+    kind: `correction:${failure.correctionType}`,
+    provenance: 'failure-derived',
+    sourceType: 'failure',
+    sourceId: failure.id,
+    projectId: failure.project ?? undefined,
+    detectedAt: failure.timestamp,
+    severity: inferFailurePressureSeverity(failure),
+    priority: inferFailurePressurePriority(failure),
+    description: failure.correction,
+    relatedFailureId: failure.id,
+    relatedActivationTraceId: failure.activationTraceId,
+    skillIds: failure.skillsActive,
+    status: failure.resolved ? 'addressed' : 'open',
+  }
+}
+
+function buildDerivedProfileGapPressureSignals(profile: ProjectProfile): PressureSignal[] {
+  return profile.gaps.map((gap, index) => ({
+    id: `pressure_profile_${profile.name}_${index}`,
+    kind: `gap:${gap.area}`,
+    provenance: 'profile-gap-derived',
+    sourceType: 'project-analysis',
+    sourceId: profile.path,
+    projectId: profile.name,
+    projectPath: profile.path,
+    detectedAt: profile.analyzedAt,
+    severity: gap.priority === 'high' ? 0.95 : gap.priority === 'medium' ? 0.75 : 0.55,
+    priority: gap.priority,
+    capability: gap.area,
+    description: gap.description,
+    suggestedAction: gap.suggestedAction,
+    status: 'open',
+  }))
+}
+
+export function loadPressureSignals(): PressureSignal[] {
+  const nativeSignals = readJsonl<PressureSignal>('pressure-signals.jsonl')
+  const failures = loadFailures()
+  const profiles = loadAllProjectProfiles()
+  const derivedFromFailures = failures.map(buildDerivedPressureSignalFromFailure)
+  const derivedFromProfiles = profiles.flatMap(buildDerivedProfileGapPressureSignals)
+  const nativeKeys = new Set(nativeSignals.map((signal) => `${signal.sourceId}:${signal.kind}`))
+  return [
+    ...nativeSignals,
+    ...derivedFromFailures.filter((signal) => !nativeKeys.has(`${signal.sourceId}:${signal.kind}`)),
+    ...derivedFromProfiles.filter((signal) => !nativeKeys.has(`${signal.sourceId}:${signal.kind}`)),
+  ].sort((a, b) => b.detectedAt.localeCompare(a.detectedAt))
+}
+
+function projectRoleForSkill(skillId: string, graph: SkillGraph): CognitiveRole {
+  const node = graph.nodes.find((entry) => entry.id === skillId)
+  if (!node) return 'hybrid'
+  return inferCognitiveRole(node)
+}
+
+export function loadCoEvolutionSummary(): CoEvolutionDashboardSummary {
+  const graph = loadGraph()
+  const pressureSignals = loadPressureSignals()
+  const rolePressure = emptyCounts(['generalist', 'specialist', 'hybrid'] as const)
+  const projectBuckets = new Map<string, ProjectPressureSummary>()
+  const areaProjects = new Map<string, Set<string>>()
+  const recommendationCounts = new Map<'research' | 'specialize' | 'create', number>()
+
+  for (const signal of pressureSignals) {
+    for (const skillId of signal.skillIds ?? []) {
+      rolePressure[projectRoleForSkill(skillId, graph)] += 1
+    }
+
+    if (signal.projectId) {
+      const existing = projectBuckets.get(signal.projectId) ?? {
+        projectId: signal.projectId,
+        totalSignals: 0,
+        nativeSignals: 0,
+        derivedSignals: 0,
+        highPrioritySignals: 0,
+        topCapabilities: [],
+      }
+      existing.totalSignals += 1
+      if (signal.provenance === 'failure-native' || signal.provenance === 'project-analysis-native') existing.nativeSignals += 1
+      else existing.derivedSignals += 1
+      if (signal.priority === 'high') existing.highPrioritySignals += 1
+      if (signal.capability && !existing.topCapabilities.includes(signal.capability) && existing.topCapabilities.length < 3) {
+        existing.topCapabilities.push(signal.capability)
+      }
+      projectBuckets.set(signal.projectId, existing)
+    }
+
+    if (signal.capability && signal.projectId) {
+      const projects = areaProjects.get(signal.capability) ?? new Set<string>()
+      projects.add(signal.projectId)
+      areaProjects.set(signal.capability, projects)
+    }
+
+    if (signal.suggestedAction) {
+      recommendationCounts.set(signal.suggestedAction, (recommendationCounts.get(signal.suggestedAction) ?? 0) + 1)
+    }
+  }
+
+  const topProjects = [...projectBuckets.values()]
+    .sort((a, b) => b.totalSignals - a.totalSignals || b.highPrioritySignals - a.highPrioritySignals)
+    .slice(0, 6)
+
+  const crossProjectGapAreas = [...areaProjects.entries()]
+    .filter(([, projects]) => projects.size >= 2)
+    .map(([area, projects]) => ({ area, projects: [...projects], count: projects.size }))
+    .sort((a, b) => b.count - a.count || a.area.localeCompare(b.area))
+    .slice(0, 6)
+
+  const activeRecommendations = [...recommendationCounts.entries()]
+    .map(([action, count]) => ({ action, count }))
+    .sort((a, b) => b.count - a.count)
+
+  return {
+    pressureSignals: {
+      total: pressureSignals.length,
+      native: pressureSignals.filter((signal) => signal.provenance === 'failure-native' || signal.provenance === 'project-analysis-native').length,
+      derived: pressureSignals.filter((signal) => signal.provenance === 'failure-derived' || signal.provenance === 'profile-gap-derived').length,
+    },
+    topProjects,
+    rolePressure,
+    crossProjectGapAreas,
+    activeRecommendations,
+  }
+}
+
 export function listProjects(): string[] {
   const failures = loadFailures()
   const projects = [...new Set(failures.map(f => f.project).filter(Boolean))] as string[]
@@ -176,3 +548,73 @@ export function getDashboardSummary() {
     skillTests: skillTests.length,
   }
 }
+
+export function loadOntologySummary(): OntologyDashboardSummary {
+  const graph = loadGraph()
+  const history = loadHistory()
+  const failures = loadFailures()
+  const artifacts = loadEvolutionArtifacts()
+  const activationTraces = loadActivationTraces()
+  const pressureSignals = loadPressureSignals()
+  const skillRoles = emptyCounts(['generalist', 'specialist', 'hybrid'] as const)
+  const stabilityStates = emptyCounts(['stable', 'adaptive', 'experimental'] as const)
+  const plasticityStates = emptyCounts(['consolidated', 'volatile', 'candidate'] as const)
+
+  for (const node of graph.nodes) {
+    skillRoles[inferCognitiveRole(node)] += 1
+    stabilityStates[inferStabilityState(node)] += 1
+    plasticityStates[inferPlasticityState(node)] += 1
+  }
+
+  const proposals = history.iterations.flatMap((iteration) => iteration.proposals)
+  const observedMutationActions = [...new Set(proposals.map((proposal) => proposal.action))].sort()
+  const evidenceBackedProposals = proposals.filter((proposal) => {
+    const judges = proposal.judges
+    const hasJudgeScores = [judges.taskCompletion, judges.correctionAlignment, judges.sideEffectCheck]
+      .every((judge) => Number.isFinite(judge.score))
+    return hasJudgeScores && proposal.regressionResult.total > 0
+  }).length
+
+  return {
+    specVersion: graph.ontologyVersion ?? DASHBOARD_ONTOLOGY_SPEC_VERSION,
+    source: graph.ontologyVersion ? 'graph' : 'compat-derived',
+    skillRoles,
+    stabilityStates,
+    plasticityStates,
+    enrichedSkillNodes: graph.nodes.filter((node) => Boolean(
+      node.cognitiveRole
+      || node.stabilityState
+      || node.plasticityState
+      || node.capabilities?.length
+      || node.lineageId,
+    )).length,
+    relationFamiliesObserved: new Set(graph.edges.map((edge) => edge.type)).size,
+    mutationOperationsObserved: observedMutationActions.length,
+    observedMutationActions,
+    evidenceBackedProposals,
+    artifacts: {
+      total: artifacts.length,
+      native: artifacts.filter((artifact) => artifact.provenance === 'native-evolution').length,
+      derived: artifacts.filter((artifact) => artifact.provenance === 'derived-history').length,
+    },
+    activationTraces: {
+      total: activationTraces.length,
+      native: activationTraces.filter((trace) => trace.provenance !== 'derived-failure').length,
+      derived: activationTraces.filter((trace) => trace.provenance === 'derived-failure').length,
+    },
+    pressureSignals: {
+      total: pressureSignals.length,
+      native: pressureSignals.filter((signal) => signal.provenance === 'failure-native' || signal.provenance === 'project-analysis-native').length,
+      derived: pressureSignals.filter((signal) => signal.provenance === 'failure-derived' || signal.provenance === 'profile-gap-derived').length,
+    },
+    annotatedFailures: {
+      pressureSignals: failures.filter((failure) => (failure.pressureSignals?.length ?? 0) > 0).length,
+      capabilityGaps: failures.filter((failure) => (failure.capabilityGaps?.length ?? 0) > 0).length,
+      activationTraces: failures.filter((failure) => Boolean(failure.activationTraceId)).length,
+    },
+  }
+}
+
+export function getOntologyDashboardSummary(): OntologyDashboardSummary {
+  return loadOntologySummary()
+}