selftune 0.2.23 → 0.2.24

package/packages/dashboard-core/src/screens/skills/SkillsLibraryScreen.tsx

@@ -0,0 +1,162 @@
+"use client";
+
+import type { ReactNode } from "react";
+import { useMemo, useState } from "react";
+
+import type { DerivedSkill, FilterTab } from "@selftune/ui/components";
+import {
+  LibraryHealthCard,
+  PendingProposalsCard,
+  SkillCardItem,
+  SkillFilterTabs,
+  SkillGridEmpty,
+  SkillHeroCard,
+  SkillHeroEmpty,
+  SkillsLibraryError,
+  SkillsLibrarySkeleton,
+} from "@selftune/ui/components";
+
+export interface SkillsLibraryHero {
+  skillName: string;
+  skillScope?: string | null;
+  platforms?: string[];
+  passRate: number | null;
+  totalChecks: number;
+  uniqueSessions: number;
+  status: DerivedSkill["status"];
+  latestEvolutionTimestamp?: string | null;
+}
+
+export interface SkillsLibraryPendingProposal {
+  id: string;
+  skillName: string | null;
+  action: string;
+}
+
+export interface SkillsLibraryScreenProps {
+  skills: DerivedSkill[];
+  heroSkill?: SkillsLibraryHero | null;
+  aggregatePassRate: number | null;
+  gradedCount: number;
+  pendingProposals: SkillsLibraryPendingProposal[];
+  isLoading: boolean;
+  error?: string | null;
+  onRetry(): void;
+  renderHeroActions(skillName: string): ReactNode;
+  renderCardActions(skillName: string): ReactNode;
+}
+
+export function SkillsLibraryScreen({
+  skills,
+  heroSkill,
+  aggregatePassRate,
+  gradedCount,
+  pendingProposals,
+  isLoading,
+  error,
+  onRetry,
+  renderHeroActions,
+  renderCardActions,
+}: SkillsLibraryScreenProps) {
+  const [filter, setFilter] = useState<FilterTab>("ALL");
+  const [sortDesc, setSortDesc] = useState(true);
+
+  const filteredSkills = useMemo(() => {
+    let result = skills;
+    if (filter !== "ALL") {
+      result = result.filter((skill) => skill.status === filter);
+    }
+    if (!sortDesc) {
+      return result;
+    }
+    return result.reduceRight<DerivedSkill[]>((acc, skill) => {
+      acc.push(skill);
+      return acc;
+    }, []);
+  }, [filter, skills, sortDesc]);
+
+  const counts = useMemo<Record<FilterTab, number>>(() => {
+    const nextCounts: Record<FilterTab, number> = {
+      ALL: skills.length,
+      HEALTHY: 0,
+      WARNING: 0,
+      CRITICAL: 0,
+      UNGRADED: 0,
+    };
+
+    for (const skill of skills) {
+      if (skill.status in nextCounts) {
+        nextCounts[skill.status as Exclude<FilterTab, "ALL">]++;
+      }
+    }
+
+    return nextCounts;
+  }, [skills]);
+
+  if (isLoading) {
+    return <SkillsLibrarySkeleton />;
+  }
+
+  if (error) {
+    return <SkillsLibraryError message={error} onRetry={onRetry} />;
+  }
+
+  return (
+    <div
+      data-parity-root="skills-library"
+      className="@container/main flex flex-1 animate-in fade-in flex-col gap-8 px-4 py-8 duration-500 lg:px-6"
+    >
+      <div>
+        <h1 className="font-headline text-4xl font-bold tracking-tight text-foreground">
+          Skills Library
+        </h1>
+        <p className="mt-2 max-w-2xl text-sm text-muted-foreground">
+          Monitor and manage your evolving skill definitions across all scopes.
+        </p>
+      </div>
+
+      <div className="grid grid-cols-12 gap-6">
+        {heroSkill ? (
+          <SkillHeroCard
+            skillName={heroSkill.skillName}
+            skillScope={heroSkill.skillScope ?? null}
+            platforms={heroSkill.platforms}
+            passRate={heroSkill.passRate}
+            totalChecks={heroSkill.totalChecks}
+            uniqueSessions={heroSkill.uniqueSessions}
+            status={heroSkill.status}
+            latestEvolutionTimestamp={heroSkill.latestEvolutionTimestamp ?? null}
+            renderActions={renderHeroActions}
+          />
+        ) : (
+          <SkillHeroEmpty />
+        )}
+
+        <div className="col-span-12 flex flex-col gap-6 lg:col-span-4">
+          <LibraryHealthCard aggregatePassRate={aggregatePassRate} gradedCount={gradedCount} />
+          <PendingProposalsCard proposals={pendingProposals} />
+        </div>
+      </div>
+
+      <div className="space-y-6">
+        <SkillFilterTabs
+          filter={filter}
+          onFilterChange={setFilter}
+          counts={counts}
+          sortDesc={sortDesc}
+          onSortToggle={() => setSortDesc((value) => !value)}
+        />
+
+        {filteredSkills.length > 0 ? (
+          <div className="grid grid-cols-1 gap-6 md:grid-cols-2 xl:grid-cols-3">
+            {filteredSkills.map((skill) => (
+              <SkillCardItem key={skill.name} skill={skill} renderActions={renderCardActions} />
+            ))}
+          </div>
+        ) : (
+          <SkillGridEmpty />
+        )}
+      </div>
+    </div>
+  );
+}

package/packages/dashboard-core/src/screens/skills/index.ts

@@ -0,0 +1,6 @@
+export {
+  SkillsLibraryScreen,
+  type SkillsLibraryHero,
+  type SkillsLibraryPendingProposal,
+  type SkillsLibraryScreenProps,
+} from "./SkillsLibraryScreen";

package/packages/telemetry-contract/fixtures/complete-push.ts

@@ -1,4 +1,4 @@
-import type { PushPayloadV2 } from "../src/schemas.js";
+import type { PushPayloadV2 } from "../src/types.js";
 
 /**
  * A valid PushPayloadV2 with at least one of every record type.

package/packages/telemetry-contract/fixtures/evidence-only-push.ts

@@ -1,4 +1,4 @@
-import type { PushPayloadV2 } from "../src/schemas.js";
+import type { PushPayloadV2 } from "../src/types.js";
 
 /**
  * A valid PushPayloadV2 with only evolution_evidence entries and

package/packages/telemetry-contract/fixtures/partial-push-no-sessions.ts

@@ -1,4 +1,4 @@
-import type { PushPayloadV2 } from "../src/schemas.js";
+import type { PushPayloadV2 } from "../src/types.js";
 
 /**
  * A valid PushPayloadV2 with zero sessions but non-empty evolution_evidence.

package/packages/telemetry-contract/fixtures/partial-push-unresolved-parents.ts

@@ -1,4 +1,4 @@
-import type { PushPayloadV2 } from "../src/schemas.js";
+import type { PushPayloadV2 } from "../src/types.js";
 
 /**
  * A valid PushPayloadV2 with invocations and prompts that reference a

package/packages/telemetry-contract/src/schemas.ts

@@ -140,10 +140,13 @@ export const CanonicalEvolutionEvidenceRecordSchema = z.object({
   evidence_id: z.string().min(1),
   skill_name: z.string().min(1),
   proposal_id: z.string().optional(),
+  timestamp: z.string().datetime().optional(),
+  skill_path: z.string().optional(),
   target: z.string().min(1),
   stage: z.string().min(1),
   rationale: z.string().optional(),
   confidence: z.number().min(0).max(1).optional(),
+  details: z.string().optional(),
   original_text: z.string().optional(),
   proposed_text: z.string().optional(),
   eval_set_json: z.unknown().optional(),
@@ -151,6 +154,37 @@ export const CanonicalEvolutionEvidenceRecordSchema = z.object({
   raw_source_ref: rawSourceRefSchema.optional(),
 });
 
+export const CanonicalGradingResultRecordSchema = z.object({
+  grading_id: z.string().min(1),
+  session_id: z.string().min(1),
+  skill_name: z.string().min(1),
+  transcript_path: z.string().nullable().optional(),
+  graded_at: z.string().min(1),
+  pass_rate: z.number().min(0).max(1).nullable().optional(),
+  mean_score: z.number().min(0).max(1).nullable().optional(),
+  score_std_dev: z.number().nullable().optional(),
+  passed_count: z.number().int().nonnegative().nullable().optional(),
+  failed_count: z.number().int().nonnegative().nullable().optional(),
+  total_count: z.number().int().nonnegative().nullable().optional(),
+  expectations_json: z.string().nullable().optional(),
+  claims_json: z.string().nullable().optional(),
+  eval_feedback_json: z.string().nullable().optional(),
+  failure_feedback_json: z.string().nullable().optional(),
+  execution_metrics_json: z.string().nullable().optional(),
+});
+
+export const CanonicalImprovementSignalRecordSchema = z.object({
+  signal_id: z.string().min(1),
+  timestamp: z.string().min(1),
+  session_id: z.string().min(1),
+  query: z.string().min(1),
+  signal_type: z.string().min(1),
+  mentioned_skill: z.string().nullable().optional(),
+  consumed: z.boolean(),
+  consumed_at: z.string().nullable().optional(),
+  consumed_by_run: z.string().nullable().optional(),
+});
+
 // ---------- Orchestrate run schemas ----------
 
 export const OrchestrateRunSkillActionSchema = z.object({
@@ -194,12 +228,14 @@ export const PushPayloadV2Schema = z.object({
     normalization_runs: z.array(CanonicalNormalizationRunRecordSchema).min(0),
     evolution_evidence: z.array(CanonicalEvolutionEvidenceRecordSchema).optional(),
     orchestrate_runs: z.array(PushOrchestrateRunRecordSchema).optional(),
+    grading_results: z.array(CanonicalGradingResultRecordSchema).optional(),
+    improvement_signals: z.array(CanonicalImprovementSignalRecordSchema).optional(),
   }),
 });
 
 // ---------- Inferred types from Zod schemas ----------
 
-export type PushPayloadV2 = z.infer<typeof PushPayloadV2Schema>;
+export type ZodPushPayloadV2 = z.infer<typeof PushPayloadV2Schema>;
 export type ZodCanonicalSessionRecord = z.infer<typeof CanonicalSessionRecordSchema>;
 export type ZodCanonicalPromptRecord = z.infer<typeof CanonicalPromptRecordSchema>;
 export type ZodCanonicalSkillInvocationRecord = z.infer<
@@ -212,4 +248,8 @@ export type ZodCanonicalNormalizationRunRecord = z.infer<
 export type ZodCanonicalEvolutionEvidenceRecord = z.infer<
   typeof CanonicalEvolutionEvidenceRecordSchema
 >;
+export type ZodCanonicalGradingResultRecord = z.infer<typeof CanonicalGradingResultRecordSchema>;
+export type ZodCanonicalImprovementSignalRecord = z.infer<
+  typeof CanonicalImprovementSignalRecordSchema
+>;
 export type ZodPushOrchestrateRunRecord = z.infer<typeof PushOrchestrateRunRecordSchema>;

package/packages/telemetry-contract/src/types.ts

@@ -54,7 +54,7 @@ export const CANONICAL_RECORD_KINDS = [
 ] as const;
 export type CanonicalRecordKind = (typeof CANONICAL_RECORD_KINDS)[number];
 
-export interface CanonicalRawSourceRef {
+export interface CanonicalRawSourceRef extends Record<string, unknown> {
   path?: string;
   line?: number;
   event_type?: string;
@@ -62,7 +62,7 @@ export interface CanonicalRawSourceRef {
   metadata?: Record<string, unknown>;
 }
 
-export interface CanonicalRecordBase {
+export interface CanonicalRecordBase extends Record<string, unknown> {
   record_kind: CanonicalRecordKind;
   schema_version: CanonicalSchemaVersion;
   normalizer_version: string;
@@ -143,6 +143,16 @@ export interface CanonicalExecutionFactRecord extends CanonicalSessionRecordBase
   errors_encountered: number;
   input_tokens?: number;
   output_tokens?: number;
+  cached_input_tokens?: number;
+  reasoning_output_tokens?: number;
+  cost_usd?: number;
+  files_changed?: number;
+  lines_added?: number;
+  lines_removed?: number;
+  lines_modified?: number;
+  artifact_count?: number;
+  session_type?: string;
+  agent_summary?: string;
   duration_ms?: number;
   completion_status?: CanonicalCompletionStatus;
   end_reason?: string;
@@ -157,9 +167,100 @@ export interface CanonicalNormalizationRunRecord extends CanonicalRecordBase {
   repair_applied: boolean;
 }
 
+export interface CanonicalEvolutionEvidenceRecord {
+  evidence_id?: string;
+  timestamp?: string;
+  proposal_id?: string;
+  skill_name: string;
+  skill_path?: string;
+  target: string;
+  stage: string;
+  rationale?: string;
+  confidence?: number;
+  details?: string;
+  original_text?: string;
+  proposed_text?: string;
+  eval_set_json?: unknown;
+  validation_json?: unknown;
+  raw_source_ref?: CanonicalRawSourceRef;
+}
+
+export interface CanonicalGradingResultRecord {
+  grading_id: string;
+  session_id: string;
+  skill_name: string;
+  transcript_path?: string | null;
+  graded_at: string;
+  pass_rate?: number | null;
+  mean_score?: number | null;
+  score_std_dev?: number | null;
+  passed_count?: number | null;
+  failed_count?: number | null;
+  total_count?: number | null;
+  expectations_json?: string | null;
+  claims_json?: string | null;
+  eval_feedback_json?: string | null;
+  failure_feedback_json?: string | null;
+  execution_metrics_json?: string | null;
+}
+
+export interface CanonicalImprovementSignalRecord {
+  signal_id: string;
+  timestamp: string;
+  session_id: string;
+  query: string;
+  signal_type: string;
+  mentioned_skill?: string | null;
+  consumed: boolean;
+  consumed_at?: string | null;
+  consumed_by_run?: string | null;
+}
+
 export type CanonicalRecord =
   | CanonicalSessionRecord
   | CanonicalPromptRecord
   | CanonicalSkillInvocationRecord
   | CanonicalExecutionFactRecord
   | CanonicalNormalizationRunRecord;
+
+export interface PushOrchestrateRunRecord {
+  run_id: string;
+  timestamp: string;
+  elapsed_ms: number;
+  dry_run: boolean;
+  approval_mode: "auto" | "review";
+  total_skills: number;
+  evaluated: number;
+  evolved: number;
+  deployed: number;
+  watched: number;
+  skipped: number;
+  skill_actions: Array<{
+    skill: string;
+    action: "evolve" | "watch" | "skip";
+    reason: string;
+    deployed?: boolean;
+    rolledBack?: boolean;
+    alert?: string | null;
+    elapsed_ms?: number;
+    llm_calls?: number;
+  }>;
+}
+
+export interface PushPayloadV2 {
+  schema_version: CanonicalSchemaVersion;
+  client_version: string;
+  push_id: string;
+  normalizer_version: string;
+  canonical: {
+    sessions: CanonicalSessionRecord[];
+    prompts: CanonicalPromptRecord[];
+    skill_invocations: CanonicalSkillInvocationRecord[];
+    execution_facts: CanonicalExecutionFactRecord[];
+    normalization_runs: CanonicalNormalizationRunRecord[];
+    evolution_evidence?: CanonicalEvolutionEvidenceRecord[];
+    orchestrate_runs?: PushOrchestrateRunRecord[];
+    grading_results?: CanonicalGradingResultRecord[];
+    improvement_signals?: CanonicalImprovementSignalRecord[];
+  };
+}

package/packages/ui/src/components/EvidenceViewer.tsx

@@ -158,6 +158,44 @@ function formatValidationValue(key: string, val: unknown): React.ReactNode {
   return <span>{String(val)}</span>;
 }
 
+function getPerEntryPassStatus(entry: unknown): boolean | null {
+  if (typeof entry !== "object" || entry === null) return null;
+  const obj = entry as Record<string, unknown>;
+  const afterPass = obj.after_pass ?? obj.after ?? obj.triggered ?? obj.result;
+  const passed = obj.passed ?? obj.matched;
+  return typeof afterPass === "boolean" ? afterPass : typeof passed === "boolean" ? passed : null;
+}
+
+function getEvidenceListKey(prefix: string, value: unknown): string {
+  if (typeof value !== "object" || value === null) {
+    return `${prefix}:${JSON.stringify(value)}`;
+  }
+
+  const record = value as Record<string, unknown>;
+  const nested =
+    typeof record.entry === "object" && record.entry !== null
+      ? (record.entry as Record<string, unknown>)
+      : null;
+  const query =
+    typeof nested?.query === "string"
+      ? nested.query
+      : typeof record.query === "string"
+        ? record.query
+        : typeof record.prompt === "string"
+          ? record.prompt
+          : typeof record.input === "string"
+            ? record.input
+            : null;
+
+  if (query) return `${prefix}:${query}`;
+
+  const action = typeof record.action === "string" ? record.action : null;
+  const timestamp = typeof record.timestamp === "string" ? record.timestamp : null;
+  if (action && timestamp) return `${prefix}:${action}:${timestamp}`;
+
+  return `${prefix}:${JSON.stringify(record)}`;
+}
+
 /** Render a per_entry_result row — handles both flat EvalEntry and nested { entry, before_pass, after_pass } */
 function PerEntryResult({ entry }: { entry: Record<string, unknown> }) {
   // Handle nested shape: { entry: { query, should_trigger }, before_pass, after_pass }
@@ -168,11 +206,7 @@ function PerEntryResult({ entry }: { entry: Record<string, unknown> }) {
   const beforePass =
     entry.before_pass ?? entry.before ?? entry.original_triggered ?? entry.baseline;
   const afterPass = entry.after_pass ?? entry.after ?? entry.triggered ?? entry.result;
-  const passed = entry.passed ?? entry.matched;
-
-  // Determine icon: use after_pass for per_entry_results, passed for others
-  const isPass =
-    typeof afterPass === "boolean" ? afterPass : typeof passed === "boolean" ? passed : null;
+  const isPass = getPerEntryPassStatus(entry);
 
   return (
     <div className="flex items-start gap-2 text-xs py-1.5 border-b border-border/50 last:border-0">
@@ -218,12 +252,22 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
     regressions,
     new_passes,
     per_entry_results,
+    validation_mode,
+    validation_agent,
+    validation_fixture_id,
+    validation_fallback_reason,
     ...rest
   } = validation;
 
   const regressionsArr = Array.isArray(regressions) ? regressions : [];
   const newPassesArr = Array.isArray(new_passes) ? new_passes : [];
   const perEntryArr = Array.isArray(per_entry_results) ? per_entry_results : [];
+  const validationMode = typeof validation_mode === "string" ? validation_mode : null;
+  const validationAgent = typeof validation_agent === "string" ? validation_agent : null;
+  const validationFixtureId =
+    typeof validation_fixture_id === "string" ? validation_fixture_id : null;
+  const validationFallbackReason =
+    typeof validation_fallback_reason === "string" ? validation_fallback_reason : null;
 
   return (
     <div className="rounded-md border bg-muted/30 p-3 space-y-3">
@@ -241,6 +285,21 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
             {improved ? "Improved" : "Regressed"}
           </Badge>
         )}
+        {validationMode && (
+          <Badge variant="outline" className="text-[10px] capitalize">
+            {validationMode.replace(/_/g, " ")}
+          </Badge>
+        )}
+        {validationAgent && (
+          <Badge variant="secondary" className="text-[10px]">
+            {validationAgent}
+          </Badge>
+        )}
+        {validationFixtureId && (
+          <Badge variant="secondary" className="text-[10px] font-mono" title={validationFixtureId}>
+            fixture #{validationFixtureId.slice(0, 8)}
+          </Badge>
+        )}
         {typeof before_pass_rate === "number" && typeof after_pass_rate === "number" && (
           <span className="text-xs font-mono text-muted-foreground">
             {(before_pass_rate * 100).toFixed(1)}% &rarr; {(after_pass_rate * 100).toFixed(1)}%
@@ -256,6 +315,12 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
         )}
       </div>
 
+      {validationFallbackReason && (
+        <div className="rounded border border-amber-300/60 bg-amber-50 px-2.5 py-2 text-[11px] text-amber-900 dark:border-amber-900/60 dark:bg-amber-950/30 dark:text-amber-200">
+          Replay fallback: {validationFallbackReason}
+        </div>
+      )}
+
       {/* New passes */}
       {newPassesArr.length > 0 && (
         <div>
@@ -263,9 +328,9 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
             New Passes ({newPassesArr.length})
           </p>
           <div className="rounded border bg-card p-2">
-            {newPassesArr.map((entry, j) => (
+            {newPassesArr.map((entry) => (
               <PerEntryResult
-                key={j}
+                key={getEvidenceListKey("new-pass", entry)}
                 entry={
                   typeof entry === "object" && entry !== null
                     ? (entry as Record<string, unknown>)
@@ -284,9 +349,9 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
             Regressions ({regressionsArr.length})
           </p>
           <div className="rounded border border-red-200 dark:border-red-900/50 bg-card p-2">
-            {regressionsArr.map((entry, j) => (
+            {regressionsArr.map((entry) => (
               <PerEntryResult
-                key={j}
+                key={getEvidenceListKey("regression", entry)}
                 entry={
                   typeof entry === "object" && entry !== null
                     ? (entry as Record<string, unknown>)
@@ -318,17 +383,7 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
 
 function PerEntryResultsSection({ entries }: { entries: unknown[] }) {
   const [expanded, setExpanded] = useState(false);
-  const passCount = entries.filter((e) => {
-    if (typeof e !== "object" || e === null) return false;
-    const obj = e as Record<string, unknown>;
-    return (
-      obj.passed === true ||
-      obj.matched === true ||
-      obj.triggered === true ||
-      obj.after === true ||
-      obj.result === true
-    );
-  }).length;
+  const passCount = entries.filter((entry) => getPerEntryPassStatus(entry) === true).length;
 
   const display = expanded ? entries : entries.slice(0, 5);
 
@@ -356,9 +411,9 @@ function PerEntryResultsSection({ entries }: { entries: unknown[] }) {
         />
       </div>
       <div className="rounded border bg-card p-2 max-h-[300px] overflow-y-auto">
-        {display.map((entry, j) => (
+        {display.map((entry) => (
           <PerEntryResult
-            key={j}
+            key={getEvidenceListKey("per-entry", entry)}
             entry={
               typeof entry === "object" && entry !== null
                 ? (entry as Record<string, unknown>)
@@ -421,13 +476,13 @@ function EvalSetSection({ evalSet }: { evalSet: Array<Record<string, unknown>> }
       </button>
       {expanded && (
         <div className="space-y-1">
-          {evalSet.map((evalEntry, j) => {
+          {evalSet.map((evalEntry) => {
             const query = evalEntry.query ?? evalEntry.prompt ?? evalEntry.input;
             const expected = evalEntry.expected ?? evalEntry.should_trigger;
             const passed = evalEntry.passed ?? evalEntry.result;
             return (
               <div
-                key={j}
+                key={getEvidenceListKey("eval-set", evalEntry)}
                 className="flex items-start gap-2 text-xs py-1 border-b border-border/50 last:border-0"
               >
                 {typeof passed === "boolean" ? (
@@ -670,7 +725,7 @@ export function EvidenceViewer({ proposalId, evolution, evidence }: Props) {
         <CardContent className="space-y-3">
           <div className="flex items-center gap-2 flex-wrap">
             {steps.map((step, i) => (
-              <div key={`${step.action}-${i}`} className="contents">
+              <div key={`${step.action}-${step.timestamp}`} className="contents">
                 {i > 0 && <ArrowRightIcon className="size-3 text-muted-foreground/50 shrink-0" />}
                 <div className="flex items-center gap-1.5 rounded-md border px-2.5 py-1.5 bg-card">
                   {ACTION_ICON[step.action]}