selftune 0.2.6 → 0.2.9

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

@@ -0,0 +1,196 @@
+import { z } from "zod";
+import {
+  CANONICAL_CAPTURE_MODES,
+  CANONICAL_COMPLETION_STATUSES,
+  CANONICAL_INVOCATION_MODES,
+  CANONICAL_PLATFORMS,
+  CANONICAL_PROMPT_KINDS,
+  CANONICAL_RECORD_KINDS,
+  CANONICAL_SCHEMA_VERSION,
+  CANONICAL_SOURCE_SESSION_KINDS,
+} from "./types.js";
+
+export const canonicalPlatformSchema = z.enum(CANONICAL_PLATFORMS);
+export const captureModeSchema = z.enum(CANONICAL_CAPTURE_MODES);
+export const sourceSessionKindSchema = z.enum(CANONICAL_SOURCE_SESSION_KINDS);
+export const promptKindSchema = z.enum(CANONICAL_PROMPT_KINDS);
+export const invocationModeSchema = z.enum(CANONICAL_INVOCATION_MODES);
+export const completionStatusSchema = z.enum(CANONICAL_COMPLETION_STATUSES);
+export const recordKindSchema = z.enum(CANONICAL_RECORD_KINDS);
+
+export const rawSourceRefSchema = z.object({
+  path: z.string().optional(),
+  line: z.number().int().nonnegative().optional(),
+  event_type: z.string().optional(),
+  raw_id: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const canonicalRecordBaseSchema = z.object({
+  record_kind: recordKindSchema,
+  schema_version: z.literal(CANONICAL_SCHEMA_VERSION),
+  normalizer_version: z.string().min(1),
+  normalized_at: z.string().datetime(),
+  platform: canonicalPlatformSchema,
+  capture_mode: captureModeSchema,
+  raw_source_ref: rawSourceRefSchema,
+});
+
+export const canonicalSessionRecordBaseSchema = canonicalRecordBaseSchema.extend({
+  source_session_kind: sourceSessionKindSchema,
+  session_id: z.string().min(1),
+});
+
+export const CanonicalSessionRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("session"),
+  external_session_id: z.string().optional(),
+  parent_session_id: z.string().optional(),
+  agent_id: z.string().optional(),
+  agent_type: z.string().optional(),
+  agent_cli: z.string().optional(),
+  session_key: z.string().optional(),
+  channel: z.string().optional(),
+  workspace_path: z.string().optional(),
+  repo_root: z.string().optional(),
+  repo_remote: z.string().optional(),
+  branch: z.string().optional(),
+  commit_sha: z.string().optional(),
+  permission_mode: z.string().optional(),
+  approval_policy: z.string().optional(),
+  sandbox_policy: z.string().optional(),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  started_at: z.string().datetime().optional(),
+  ended_at: z.string().datetime().optional(),
+  completion_status: completionStatusSchema.optional(),
+  end_reason: z.string().optional(),
+});
+
+export const CanonicalPromptRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("prompt"),
+  prompt_id: z.string().min(1),
+  occurred_at: z.string().datetime(),
+  prompt_text: z.string().min(1),
+  prompt_hash: z.string().optional(),
+  prompt_kind: promptKindSchema,
+  is_actionable: z.boolean(),
+  prompt_index: z.number().int().nonnegative().optional(),
+  parent_prompt_id: z.string().optional(),
+  source_message_id: z.string().optional(),
+});
+
+export const CanonicalSkillInvocationRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("skill_invocation"),
+  skill_invocation_id: z.string().min(1),
+  occurred_at: z.string().datetime(),
+  matched_prompt_id: z.string().min(1).optional(),
+  skill_name: z.string().min(1),
+  skill_path: z.string().optional(),
+  skill_version_hash: z.string().optional(),
+  invocation_mode: invocationModeSchema,
+  triggered: z.boolean(),
+  confidence: z.number().min(0).max(1),
+  tool_name: z.string().optional(),
+  tool_call_id: z.string().optional(),
+  agent_type: z.string().optional(),
+});
+
+export const CanonicalExecutionFactRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("execution_fact"),
+  execution_fact_id: z.string().min(1),
+  occurred_at: z.string().datetime(),
+  prompt_id: z.string().optional(),
+  tool_calls_json: z.record(z.string(), z.number().finite()),
+  total_tool_calls: z.number().int().nonnegative(),
+  bash_commands_redacted: z.array(z.string()).optional(),
+  assistant_turns: z.number().int().nonnegative(),
+  errors_encountered: z.number().int().nonnegative(),
+  input_tokens: z.number().int().nonnegative().optional(),
+  output_tokens: z.number().int().nonnegative().optional(),
+  duration_ms: z.number().nonnegative().optional(),
+  completion_status: completionStatusSchema.optional(),
+  end_reason: z.string().optional(),
+});
+
+export const CanonicalNormalizationRunRecordSchema = canonicalRecordBaseSchema.extend({
+  record_kind: z.literal("normalization_run"),
+  run_id: z.string().min(1),
+  run_at: z.string().datetime(),
+  raw_records_seen: z.number().int().nonnegative(),
+  canonical_records_written: z.number().int().nonnegative(),
+  repair_applied: z.boolean(),
+});
+
+export const CanonicalEvolutionEvidenceRecordSchema = z.object({
+  evidence_id: z.string().min(1),
+  skill_name: z.string().min(1),
+  proposal_id: 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(),
+  original_text: z.string().optional(),
+  proposed_text: z.string().optional(),
+  eval_set_json: z.unknown().optional(),
+  validation_json: z.unknown().optional(),
+  raw_source_ref: rawSourceRefSchema.optional(),
+});
+
+export const OrchestrateRunSkillActionSchema = z.object({
+  skill: z.string().min(1),
+  action: z.enum(["evolve", "watch", "skip"]),
+  reason: z.string(),
+  deployed: z.boolean().optional(),
+  rolledBack: z.boolean().optional(),
+  alert: z.string().nullable().optional(),
+  elapsed_ms: z.number().nonnegative().optional(),
+  llm_calls: z.number().int().nonnegative().optional(),
+});
+
+export const PushOrchestrateRunRecordSchema = z.object({
+  run_id: z.string().min(1),
+  timestamp: z.string().datetime(),
+  elapsed_ms: z.number().int().nonnegative(),
+  dry_run: z.boolean(),
+  approval_mode: z.enum(["auto", "review"]),
+  total_skills: z.number().int().nonnegative(),
+  evaluated: z.number().int().nonnegative(),
+  evolved: z.number().int().nonnegative(),
+  deployed: z.number().int().nonnegative(),
+  watched: z.number().int().nonnegative(),
+  skipped: z.number().int().nonnegative(),
+  skill_actions: z.array(OrchestrateRunSkillActionSchema),
+});
+
+export const PushPayloadV2Schema = z.object({
+  schema_version: z.literal("2.0"),
+  client_version: z.string().min(1),
+  // Queue-generated push IDs are typically UUIDs, but the wire contract only
+  // requires a stable non-empty idempotency key.
+  push_id: z.string().min(1),
+  normalizer_version: z.string().min(1),
+  canonical: z.object({
+    sessions: z.array(CanonicalSessionRecordSchema).min(0),
+    prompts: z.array(CanonicalPromptRecordSchema).min(0),
+    skill_invocations: z.array(CanonicalSkillInvocationRecordSchema).min(0),
+    execution_facts: z.array(CanonicalExecutionFactRecordSchema).min(0),
+    normalization_runs: z.array(CanonicalNormalizationRunRecordSchema).min(0),
+    evolution_evidence: z.array(CanonicalEvolutionEvidenceRecordSchema).optional(),
+    orchestrate_runs: z.array(PushOrchestrateRunRecordSchema).optional(),
+  }),
+});
+
+export type PushPayloadV2 = z.infer<typeof PushPayloadV2Schema>;
+export type ZodCanonicalSessionRecord = z.infer<typeof CanonicalSessionRecordSchema>;
+export type ZodCanonicalPromptRecord = z.infer<typeof CanonicalPromptRecordSchema>;
+export type ZodCanonicalSkillInvocationRecord = z.infer<
+  typeof CanonicalSkillInvocationRecordSchema
+>;
+export type ZodCanonicalExecutionFactRecord = z.infer<typeof CanonicalExecutionFactRecordSchema>;
+export type ZodCanonicalNormalizationRunRecord = z.infer<
+  typeof CanonicalNormalizationRunRecordSchema
+>;
+export type ZodCanonicalEvolutionEvidenceRecord = z.infer<
+  typeof CanonicalEvolutionEvidenceRecordSchema
+>;
+export type ZodPushOrchestrateRunRecord = z.infer<typeof PushOrchestrateRunRecordSchema>;

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

@@ -128,15 +128,17 @@ export interface CanonicalSkillInvocationRecord extends CanonicalSessionRecordBa
   confidence: number;
   tool_name?: string;
   tool_call_id?: string;
+  agent_type?: string;
 }
 
 export interface CanonicalExecutionFactRecord extends CanonicalSessionRecordBase {
   record_kind: "execution_fact";
+  execution_fact_id: string;
   occurred_at: string;
   prompt_id?: string;
   tool_calls_json: Record<string, number>;
   total_tool_calls: number;
-  bash_commands_redacted: string[];
+  bash_commands_redacted?: string[];
   assistant_turns: number;
   errors_encountered: number;
   input_tokens?: number;

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

@@ -86,10 +86,12 @@ export function isCanonicalRecord(value: unknown): value is CanonicalRecord {
     case "execution_fact":
       return (
         hasSessionScope(value) &&
+        hasString(value, "execution_fact_id") &&
         hasString(value, "occurred_at") &&
         isNumberRecord(value.tool_calls_json) &&
         isFiniteNumber(value.total_tool_calls) &&
-        isStringArray(value.bash_commands_redacted) &&
+        (value.bash_commands_redacted === undefined ||
+          isStringArray(value.bash_commands_redacted)) &&
         isFiniteNumber(value.assistant_turns) &&
         isFiniteNumber(value.errors_encountered) &&
         (value.completion_status === undefined ||

package/packages/telemetry-contract/tests/compatibility.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, test } from "bun:test";
+import { completePush } from "../fixtures/complete-push.js";
+import { evidenceOnlyPush } from "../fixtures/evidence-only-push.js";
+import { partialPushNoSessions } from "../fixtures/partial-push-no-sessions.js";
+import { partialPushUnresolvedParents } from "../fixtures/partial-push-unresolved-parents.js";
+import { PushPayloadV2Schema } from "../src/schemas.js";
+
+describe("PushPayloadV2Schema compatibility", () => {
+  // ---- Fixture validation ----
+
+  test("complete-push fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(completePush);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  test("partial-push-no-sessions fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(partialPushNoSessions);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  test("partial-push-unresolved-parents fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  test("evidence-only-push fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(evidenceOnlyPush);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  // ---- execution_fact_id is required ----
+
+  test("execution_fact_id is required on execution facts", () => {
+    const badPayload = structuredClone(completePush);
+    delete (badPayload.canonical.execution_facts[0] as Record<string, unknown>).execution_fact_id;
+    const result = PushPayloadV2Schema.safeParse(badPayload);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const paths = result.error.issues.map((i) => i.path.join("."));
+      expect(paths).toContain("canonical.execution_facts.0.execution_fact_id");
+    }
+  });
+
+  test("execution_fact_id rejects empty string", () => {
+    const badPayload = structuredClone(completePush);
+    (badPayload.canonical.execution_facts[0] as Record<string, unknown>).execution_fact_id = "";
+    const result = PushPayloadV2Schema.safeParse(badPayload);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const paths = result.error.issues.map((i) => i.path.join("."));
+      expect(paths).toContain("canonical.execution_facts.0.execution_fact_id");
+    }
+  });
+
+  // ---- bash_commands_redacted is optional ----
+
+  test("bash_commands_redacted is optional (omitting it passes)", () => {
+    // The unresolved-parents fixture already omits bash_commands_redacted
+    const ef = partialPushUnresolvedParents.canonical.execution_facts[0];
+    expect(ef.bash_commands_redacted).toBeUndefined();
+
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    expect(result.success).toBe(true);
+  });
+
+  test("bash_commands_redacted accepts an array when present", () => {
+    const ef = completePush.canonical.execution_facts[0];
+    expect(Array.isArray(ef.bash_commands_redacted)).toBe(true);
+
+    const result = PushPayloadV2Schema.safeParse(completePush);
+    expect(result.success).toBe(true);
+  });
+
+  // ---- Zero-session pushes ----
+
+  test("zero-session pushes pass validation", () => {
+    expect(partialPushNoSessions.canonical.sessions).toHaveLength(0);
+    const result = PushPayloadV2Schema.safeParse(partialPushNoSessions);
+    expect(result.success).toBe(true);
+  });
+
+  test("evidence-only push with all empty arrays passes", () => {
+    expect(evidenceOnlyPush.canonical.sessions).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.prompts).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.skill_invocations).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.execution_facts).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.normalization_runs).toHaveLength(0);
+    const result = PushPayloadV2Schema.safeParse(evidenceOnlyPush);
+    expect(result.success).toBe(true);
+  });
+
+  // ---- Unresolved parent references ----
+
+  test("unresolved parent references pass (invocation references session_id not in sessions)", () => {
+    const sessionIds = new Set(
+      partialPushUnresolvedParents.canonical.sessions.map((s) => s.session_id),
+    );
+    const invSessionIds = partialPushUnresolvedParents.canonical.skill_invocations.map(
+      (i) => i.session_id,
+    );
+
+    // Precondition: arrays must be non-empty for the test to be meaningful
+    expect(invSessionIds.length).toBeGreaterThan(0);
+
+    // Confirm the invocation references a session not in the sessions array
+    for (const sid of invSessionIds) {
+      expect(sessionIds.has(sid)).toBe(false);
+    }
+
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    expect(result.success).toBe(true);
+  });
+
+  test("prompts with unresolved session_id pass validation", () => {
+    const sessionIds = new Set(
+      partialPushUnresolvedParents.canonical.sessions.map((s) => s.session_id),
+    );
+    const promptSessionIds = partialPushUnresolvedParents.canonical.prompts.map(
+      (p) => p.session_id,
+    );
+
+    // Precondition: arrays must be non-empty for the test to be meaningful
+    expect(promptSessionIds.length).toBeGreaterThan(0);
+
+    for (const sid of promptSessionIds) {
+      expect(sessionIds.has(sid)).toBe(false);
+    }
+
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    expect(result.success).toBe(true);
+  });
+});

package/packages/ui/package.json

@@ -25,6 +25,10 @@
     "lucide-react": "^0.577.0",
     "tailwind-merge": "^3.5.0"
   },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0"
+  },
   "peerDependencies": {
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

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

@@ -7,6 +7,7 @@ import {
   CardTitle,
 } from "../primitives/card"
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "../primitives/tabs"
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../primitives/tooltip"
 import type { EvolutionEntry, PendingProposal, UnmatchedQuery } from "../types"
 import { timeAgo } from "../lib/format"
 import {
@@ -29,10 +30,12 @@ export function ActivityPanel({
   evolution,
   pendingProposals,
   unmatchedQueries,
+  onSelectProposal,
 }: {
   evolution: EvolutionEntry[]
   pendingProposals: PendingProposal[]
   unmatchedQueries: UnmatchedQuery[]
+  onSelectProposal?: (skillName: string, proposalId: string) => void
 }) {
   const hasActivity = evolution.length > 0 || pendingProposals.length > 0 || unmatchedQueries.length > 0
 
@@ -73,35 +76,51 @@ export function ActivityPanel({
                 : "unmatched"
           }
         >
-          <TabsList className="w-full">
-            {pendingProposals.length > 0 && (
-              <TabsTrigger value="pending" className="flex-1 gap-1.5">
-                <GitPullRequestArrowIcon className="size-3.5" />
-                Pending
-                <Badge variant="secondary" className="ml-1 h-4 px-1.5 text-[10px]">
-                  {pendingProposals.length}
-                </Badge>
-              </TabsTrigger>
-            )}
-            <TabsTrigger value="timeline" className="flex-1 gap-1.5">
-              <ClockIcon className="size-3.5" />
-              Timeline
-            </TabsTrigger>
-            {unmatchedQueries.length > 0 && (
-              <TabsTrigger value="unmatched" className="flex-1 gap-1.5">
-                <SearchXIcon className="size-3.5" />
-                Unmatched
-                <Badge variant="destructive" className="ml-1 h-4 px-1.5 text-[10px]">
-                  {unmatchedQueries.length}
-                </Badge>
-              </TabsTrigger>
-            )}
-          </TabsList>
+          <TooltipProvider>
+            <TabsList className="w-full">
+              {pendingProposals.length > 0 && (
+                <Tooltip>
+                  <TooltipTrigger render={<TabsTrigger value="pending" className="flex-1 gap-1.5" />}>
+                    <GitPullRequestArrowIcon className="size-3.5" />
+                    <Badge variant="secondary" className="h-4 px-1 text-[10px]">
+                      {pendingProposals.length}
+                    </Badge>
+                  </TooltipTrigger>
+                  <TooltipContent>Pending proposals</TooltipContent>
+                </Tooltip>
+              )}
+              <Tooltip>
+                <TooltipTrigger render={<TabsTrigger value="timeline" className="flex-1" />}>
+                  <ClockIcon className="size-3.5" />
+                </TooltipTrigger>
+                <TooltipContent>Timeline</TooltipContent>
+              </Tooltip>
+              {unmatchedQueries.length > 0 && (
+                <Tooltip>
+                  <TooltipTrigger render={<TabsTrigger value="unmatched" className="flex-1 gap-1.5" />}>
+                    <SearchXIcon className="size-3.5" />
+                    <Badge variant="destructive" className="h-4 px-1 text-[10px]">
+                      {unmatchedQueries.length}
+                    </Badge>
+                  </TooltipTrigger>
+                  <TooltipContent>Unmatched queries</TooltipContent>
+                </Tooltip>
+              )}
+            </TabsList>
+          </TooltipProvider>
 
           {pendingProposals.length > 0 && (
             <TabsContent value="pending" className="mt-4 space-y-3">
               {pendingProposals.slice(0, 10).map((p) => (
-                <div key={p.proposal_id} className="flex gap-3">
+                <button
+                  key={p.proposal_id}
+                  type="button"
+                  onClick={() => {
+                    if (p.skill_name && onSelectProposal) onSelectProposal(p.skill_name, p.proposal_id)
+                  }}
+                  disabled={!p.skill_name || !onSelectProposal}
+                  className="flex w-full gap-3 rounded-md p-1.5 text-left transition-colors enabled:hover:bg-accent/40 disabled:cursor-default"
+                >
                   <div className="mt-1 size-2 shrink-0 rounded-full bg-amber-400" />
                   <div className="flex-1 min-w-0 space-y-1">
                     <div className="flex items-center gap-2">
@@ -113,15 +132,28 @@ export function ActivityPanel({
                       </span>
                     </div>
                     <p className="text-xs text-muted-foreground line-clamp-2">{p.details}</p>
+                    {p.skill_name && (
+                      <span className="text-[10px] text-muted-foreground/60 font-mono">
+                        {p.skill_name} · #{p.proposal_id.slice(0, 8)}
+                      </span>
+                    )}
                   </div>
-                </div>
+                </button>
               ))}
             </TabsContent>
           )}
 
           <TabsContent value="timeline" className="mt-4 space-y-3">
             {evolution.slice(0, 30).map((entry, i) => (
-              <div key={`${entry.proposal_id}-${i}`} className="flex gap-3">
+              <button
+                key={`${entry.proposal_id}-${i}`}
+                type="button"
+                onClick={() => {
+                  if (entry.skill_name && onSelectProposal) onSelectProposal(entry.skill_name, entry.proposal_id)
+                }}
+                disabled={!entry.skill_name || !onSelectProposal}
+                className="flex w-full gap-3 rounded-md p-1.5 text-left transition-colors enabled:hover:bg-accent/40 disabled:cursor-default"
+              >
                 <div className={`mt-1 size-2 shrink-0 rounded-full ${
                   entry.action === "deployed" ? "bg-emerald-500"
                   : entry.action === "rejected" || entry.action === "rolled_back" ? "bg-red-500"
@@ -139,10 +171,10 @@ export function ActivityPanel({
                   </div>
                   <p className="text-xs text-muted-foreground line-clamp-2">{entry.details}</p>
                   <span className="text-[10px] text-muted-foreground/60 font-mono">
-                    #{entry.proposal_id.slice(0, 8)}
+                    {entry.skill_name ? `${entry.skill_name} · ` : ""}#{entry.proposal_id.slice(0, 8)}
                   </span>
                 </div>
-              </div>
+              </button>
             ))}
             {evolution.length === 0 && (
               <p className="text-sm text-muted-foreground text-center py-4">No timeline events</p>

package/packages/ui/src/components/section-cards.tsx

@@ -25,6 +25,7 @@ interface SectionCardsProps {
   sessionsCount: number
   pendingCount: number
   evidenceCount: number
+  hasEvolution?: boolean
 }
 
 export function SectionCards({
@@ -34,6 +35,7 @@ export function SectionCards({
   sessionsCount,
   pendingCount,
   evidenceCount,
+  hasEvolution = true,
 }: SectionCardsProps) {
   const passRateStr = avgPassRate !== null ? `${Math.round(avgPassRate * 100)}%` : "--"
   const passRateGood = avgPassRate !== null && avgPassRate >= 0.7
@@ -63,14 +65,14 @@ export function SectionCards({
         <CardHeader>
           <CardDescription className="flex items-center gap-1.5">
             <FlaskConicalIcon className="size-3.5" />
-            Avg Pass Rate
-            <InfoTip text="Average percentage of eval test cases that passed across all graded skills (5+ checks)" />
+            Avg Trigger Rate
+            <InfoTip text="Average percentage of skill checks that resulted in a trigger across all graded skills (5+ checks). Run selftune evolve to improve this." />
           </CardDescription>
           <CardTitle className={`text-2xl font-semibold tabular-nums @[250px]/card:text-3xl ${!passRateGood && avgPassRate !== null ? "text-red-600" : ""}`}>
             {passRateStr}
           </CardTitle>
-          {avgPassRate !== null && (
-            <CardAction>
+          <CardAction>
+            {avgPassRate !== null ? (
               <Badge variant={passRateGood ? "outline" : "destructive"}>
                 {passRateGood ? (
                   <TrendingUpIcon className="size-3" />
@@ -79,8 +81,12 @@ export function SectionCards({
                 )}
                 {passRateStr}
               </Badge>
-            </CardAction>
-          )}
+            ) : (
+              <Badge variant="secondary" className="text-[10px]">
+                needs 5+ checks
+              </Badge>
+            )}
+          </CardAction>
         </CardHeader>
       </Card>
 
@@ -123,18 +129,22 @@ export function SectionCards({
           <CardDescription className="flex items-center gap-1.5">
             <AlertTriangleIcon className="size-3.5" />
             Pending Proposals
-            <InfoTip text="Evolution proposals that have been generated but not yet validated or deployed" />
+            <InfoTip text="Evolution proposals that have been generated but not yet validated or deployed. Requires running selftune evolve." />
           </CardDescription>
           <CardTitle className="text-2xl font-semibold tabular-nums @[250px]/card:text-3xl">
-            {pendingCount}
+            {hasEvolution ? pendingCount : "--"}
           </CardTitle>
-          {pendingCount > 0 && (
-            <CardAction>
+          <CardAction>
+            {!hasEvolution ? (
+              <Badge variant="secondary" className="text-[10px]">
+                no evolution runs yet
+              </Badge>
+            ) : pendingCount > 0 ? (
               <Badge variant="secondary">
                 awaiting review
               </Badge>
-            </CardAction>
-          )}
+            ) : null}
+          </CardAction>
         </CardHeader>
       </Card>
 
@@ -143,11 +153,18 @@ export function SectionCards({
           <CardDescription className="flex items-center gap-1.5">
             <EyeIcon className="size-3.5" />
             Total Evidence
-            <InfoTip text="Number of evidence entries documenting skill changes with before/after validation results" />
+            <InfoTip text="Number of evidence entries documenting skill changes with before/after validation results. Requires running selftune evolve." />
           </CardDescription>
           <CardTitle className="text-2xl font-semibold tabular-nums @[250px]/card:text-3xl">
-            {evidenceCount}
+            {hasEvolution ? evidenceCount : "--"}
           </CardTitle>
+          {!hasEvolution && (
+            <CardAction>
+              <Badge variant="secondary" className="text-[10px]">
+                no evolution runs yet
+              </Badge>
+            </CardAction>
+          )}
         </CardHeader>
       </Card>
     </div>

package/packages/ui/src/types.ts

@@ -27,6 +27,7 @@ export interface EvalSnapshot {
 export interface EvolutionEntry {
   timestamp: string;
   proposal_id: string;
+  skill_name?: string;
   action: string;
   details: string;
   eval_snapshot?: EvalSnapshot | null;