selftune 0.2.19 → 0.2.21

package/cli/selftune/evolution/validate-routing.ts

@@ -5,9 +5,43 @@
  * and running trigger accuracy checks against an eval set.
  */
 
-import type { BodyEvolutionProposal, BodyValidationResult, EvalEntry } from "../types.js";
+import type {
+  BodyEvolutionProposal,
+  BodyValidationResult,
+  EvalEntry,
+  RoutingReplayEntryResult,
+  RoutingReplayFixture,
+  ValidationMode,
+} from "../types.js";
 import { callLlm } from "../utils/llm-call.js";
 import { buildTriggerCheckPrompt, parseTriggerResponse } from "../utils/trigger-check.js";
+import { runHostReplayFixture } from "./validate-host-replay.js";
+
+export interface RoutingReplayRunnerInput {
+  routing: string;
+  evalSet: EvalEntry[];
+  agent: string;
+  fixture: RoutingReplayFixture;
+}
+
+export type RoutingReplayRunner = (
+  input: RoutingReplayRunnerInput,
+) => Promise<RoutingReplayEntryResult[]>;
+
+export interface RoutingValidationOptions {
+  replayFixture?: RoutingReplayFixture;
+  replayRunner?: RoutingReplayRunner;
+}
+
+export interface RoutingTriggerAccuracyResult {
+  before_pass_rate: number;
+  after_pass_rate: number;
+  improved: boolean;
+  validation_mode: ValidationMode;
+  validation_agent: string;
+  validation_fixture_id?: string;
+  per_entry_results?: RoutingReplayEntryResult[];
+}
 
 // ---------------------------------------------------------------------------
 // Structural validation
@@ -77,9 +111,70 @@ export async function validateRoutingTriggerAccuracy(
   evalSet: EvalEntry[],
   agent: string,
   modelFlag?: string,
-): Promise<{ before_pass_rate: number; after_pass_rate: number; improved: boolean }> {
+  options: RoutingValidationOptions = {},
+): Promise<RoutingTriggerAccuracyResult> {
   if (evalSet.length === 0) {
-    return { before_pass_rate: 0, after_pass_rate: 0, improved: false };
+    return {
+      before_pass_rate: 0,
+      after_pass_rate: 0,
+      improved: false,
+      validation_mode: "structural_guard",
+      validation_agent: agent,
+    };
+  }
+
+  if (options.replayFixture && options.replayRunner) {
+    const beforeResults = await options.replayRunner({
+      routing: originalRouting,
+      evalSet,
+      agent,
+      fixture: options.replayFixture,
+    });
+    const afterResults = await options.replayRunner({
+      routing: proposedRouting,
+      evalSet,
+      agent,
+      fixture: options.replayFixture,
+    });
+    const beforePassed = beforeResults.filter((result) => result.passed).length;
+    const afterPassed = afterResults.filter((result) => result.passed).length;
+    const total = evalSet.length;
+
+    return {
+      before_pass_rate: beforePassed / total,
+      after_pass_rate: afterPassed / total,
+      improved: afterPassed > beforePassed,
+      validation_mode: "host_replay",
+      validation_agent: agent,
+      validation_fixture_id: options.replayFixture.fixture_id,
+      per_entry_results: afterResults,
+    };
+  }
+
+  if (options.replayFixture) {
+    const beforeResults = runHostReplayFixture({
+      routing: originalRouting,
+      evalSet,
+      fixture: options.replayFixture,
+    });
+    const afterResults = runHostReplayFixture({
+      routing: proposedRouting,
+      evalSet,
+      fixture: options.replayFixture,
+    });
+    const beforePassed = beforeResults.filter((result) => result.passed).length;
+    const afterPassed = afterResults.filter((result) => result.passed).length;
+    const total = evalSet.length;
+
+    return {
+      before_pass_rate: beforePassed / total,
+      after_pass_rate: afterPassed / total,
+      improved: afterPassed > beforePassed,
+      validation_mode: "host_replay",
+      validation_agent: agent,
+      validation_fixture_id: options.replayFixture.fixture_id,
+      per_entry_results: afterResults,
+    };
   }
 
   const systemPrompt = "You are an evaluation assistant. Answer only YES or NO.";
@@ -113,6 +208,8 @@ export async function validateRoutingTriggerAccuracy(
     before_pass_rate: beforePassRate,
     after_pass_rate: afterPassRate,
     improved: afterPassRate > beforePassRate,
+    validation_mode: "llm_judge",
+    validation_agent: agent,
   };
 }
 
@@ -126,6 +223,7 @@ export async function validateRoutingProposal(
   evalSet: EvalEntry[],
   agent: string,
   modelFlag?: string,
+  options: RoutingValidationOptions = {},
 ): Promise<BodyValidationResult> {
   const gateResults: Array<{ gate: string; passed: boolean; reason: string }> = [];
 
@@ -145,6 +243,8 @@ export async function validateRoutingProposal(
       gate_results: gateResults,
       improved: false,
       regressions: [],
+      validation_mode: "structural_guard",
+      validation_agent: agent,
     };
   }
 
@@ -155,13 +255,14 @@ export async function validateRoutingProposal(
     evalSet,
     agent,
     modelFlag,
+    options,
   );
   gateResults.push({
     gate: "trigger_accuracy",
     passed: accuracy.improved,
     reason: accuracy.improved
-      ? `Improved: ${(accuracy.before_pass_rate * 100).toFixed(1)}% -> ${(accuracy.after_pass_rate * 100).toFixed(1)}%`
-      : `Not improved: ${(accuracy.before_pass_rate * 100).toFixed(1)}% -> ${(accuracy.after_pass_rate * 100).toFixed(1)}%`,
+      ? `Improved via ${accuracy.validation_mode}: ${(accuracy.before_pass_rate * 100).toFixed(1)}% -> ${(accuracy.after_pass_rate * 100).toFixed(1)}%`
+      : `Not improved via ${accuracy.validation_mode}: ${(accuracy.before_pass_rate * 100).toFixed(1)}% -> ${(accuracy.after_pass_rate * 100).toFixed(1)}%`,
   });
 
   const gatesPassed = gateResults.filter((g) => g.passed).length;
@@ -173,5 +274,11 @@ export async function validateRoutingProposal(
     gate_results: gateResults,
     improved: gatesPassed === 2,
     regressions: [],
+    validation_mode: accuracy.validation_mode,
+    validation_agent: accuracy.validation_agent,
+    validation_fixture_id: accuracy.validation_fixture_id,
+    before_pass_rate: accuracy.before_pass_rate,
+    after_pass_rate: accuracy.after_pass_rate,
+    per_entry_results: accuracy.per_entry_results,
   };
 }

package/cli/selftune/localdb/direct-write.ts

@@ -285,11 +285,12 @@ export function writeEvolutionAuditToDb(record: EvolutionAuditEntry): boolean {
   return safeWrite("evolution-audit", (db) => {
     getStmt(
       db,
-      "evolution-audit-v2",
+      "evolution-audit-v3",
       `
       INSERT OR IGNORE INTO evolution_audit
-        (timestamp, proposal_id, skill_name, action, details, eval_snapshot_json, iterations_used)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+        (timestamp, proposal_id, skill_name, action, details, eval_snapshot_json, iterations_used,
+         validation_mode, validation_agent, validation_fixture_id, validation_evidence_ref)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
     ).run(
       record.timestamp,
@@ -299,6 +300,10 @@ export function writeEvolutionAuditToDb(record: EvolutionAuditEntry): boolean {
       record.details,
       record.eval_snapshot ? JSON.stringify(record.eval_snapshot) : null,
       record.iterations_used ?? null,
+      record.validation_mode ?? null,
+      record.validation_agent ?? null,
+      record.validation_fixture_id ?? null,
+      record.validation_evidence_ref ?? null,
     );
   });
 }

package/cli/selftune/localdb/materialize.ts

@@ -600,8 +600,9 @@ function insertEvolutionAudit(db: Database, records: EvolutionAuditEntry[]): num
   // (idx_evo_audit_dedup defined in schema.ts).
   const stmt = db.prepare(`
     INSERT OR IGNORE INTO evolution_audit
-      (timestamp, proposal_id, skill_name, action, details, eval_snapshot_json, iterations_used)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
+      (timestamp, proposal_id, skill_name, action, details, eval_snapshot_json, iterations_used,
+       validation_mode, validation_agent, validation_fixture_id, validation_evidence_ref)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
 
   let count = 0;
@@ -614,6 +615,10 @@ function insertEvolutionAudit(db: Database, records: EvolutionAuditEntry[]): num
       r.details,
       r.eval_snapshot ? JSON.stringify(r.eval_snapshot) : null,
       r.iterations_used ?? null,
+      r.validation_mode ?? null,
+      r.validation_agent ?? null,
+      r.validation_fixture_id ?? null,
+      r.validation_evidence_ref ?? null,
     );
     count++;
   }

package/cli/selftune/localdb/queries.ts

@@ -1130,6 +1130,10 @@ export function queryEvolutionAudit(
   action: string;
   details: string;
   eval_snapshot?: Record<string, unknown>;
+  validation_mode?: string;
+  validation_agent?: string;
+  validation_fixture_id?: string;
+  validation_evidence_ref?: string;
 }> {
   const sql = skillName
     ? `SELECT * FROM evolution_audit
@@ -1143,12 +1147,18 @@ export function queryEvolutionAudit(
   return rows.map((r) => ({
     timestamp: r.timestamp as string,
     proposal_id: r.proposal_id as string,
-    skill_name: r.skill_name as string | undefined,
+    skill_name: typeof r.skill_name === "string" ? r.skill_name : undefined,
     action: r.action as string,
     details: r.details as string,
     eval_snapshot: r.eval_snapshot_json
       ? (safeParseJson(r.eval_snapshot_json as string) as Record<string, unknown>)
       : undefined,
+    validation_mode: typeof r.validation_mode === "string" ? r.validation_mode : undefined,
+    validation_agent: typeof r.validation_agent === "string" ? r.validation_agent : undefined,
+    validation_fixture_id:
+      typeof r.validation_fixture_id === "string" ? r.validation_fixture_id : undefined,
+    validation_evidence_ref:
+      typeof r.validation_evidence_ref === "string" ? r.validation_evidence_ref : undefined,
   }));
 }
 

package/cli/selftune/localdb/schema.ts

@@ -121,7 +121,12 @@ CREATE TABLE IF NOT EXISTS evolution_audit (
   skill_name      TEXT,
   action          TEXT NOT NULL,
   details         TEXT,
-  eval_snapshot_json TEXT
+  eval_snapshot_json TEXT,
+  iterations_used  INTEGER,
+  validation_mode  TEXT,
+  validation_agent TEXT,
+  validation_fixture_id TEXT,
+  validation_evidence_ref TEXT
 )`;
 
 // -- Local telemetry tables (from JSONL logs) ---------------------------------
@@ -369,6 +374,10 @@ export const MIGRATIONS = [
   `ALTER TABLE skill_invocations ADD COLUMN source TEXT`,
   // Track how many iteration loops each evolution run used
   `ALTER TABLE evolution_audit ADD COLUMN iterations_used INTEGER`,
+  `ALTER TABLE evolution_audit ADD COLUMN validation_mode TEXT`,
+  `ALTER TABLE evolution_audit ADD COLUMN validation_agent TEXT`,
+  `ALTER TABLE evolution_audit ADD COLUMN validation_fixture_id TEXT`,
+  `ALTER TABLE evolution_audit ADD COLUMN validation_evidence_ref TEXT`,
   // Canonical contract fields for upload staging (sessions already has schema_version, platform, normalized_at)
   `ALTER TABLE sessions ADD COLUMN normalizer_version TEXT`,
   `ALTER TABLE sessions ADD COLUMN capture_mode TEXT`,

package/cli/selftune/routes/skill-report.ts

@@ -28,7 +28,8 @@ export function handleSkillReport(
   // 1. Evolution audit with eval_snapshot
   const evolution = db
     .query(
-      `SELECT timestamp, proposal_id, skill_name, action, details, eval_snapshot_json
+      `SELECT timestamp, proposal_id, skill_name, action, details, eval_snapshot_json,
+              validation_mode, validation_agent, validation_fixture_id, validation_evidence_ref
        FROM evolution_audit
        WHERE skill_name = ? OR (skill_name IS NULL AND proposal_id LIKE 'evo-' || ? || '-%')
        ORDER BY timestamp DESC
@@ -41,6 +42,10 @@ export function handleSkillReport(
     action: string;
     details: string;
     eval_snapshot_json: string | null;
+    validation_mode: string | null;
+    validation_agent: string | null;
+    validation_fixture_id: string | null;
+    validation_evidence_ref: string | null;
   }>;
   const evolutionWithSnapshot = evolution.map((e) => ({
     ...e,

package/cli/selftune/types.ts

@@ -400,6 +400,10 @@ export interface EvolutionAuditEntry {
   details: string;
   eval_snapshot?: EvalPassRate;
   iterations_used?: number;
+  validation_mode?: ValidationMode;
+  validation_agent?: string;
+  validation_fixture_id?: string;
+  validation_evidence_ref?: string;
 }
 
 export interface EvolutionEvidenceValidation {
@@ -413,6 +417,10 @@ export interface EvolutionEvidenceValidation {
   gates_passed?: number;
   gates_total?: number;
   gate_results?: Array<{ gate: ValidationGate; passed: boolean; reason: string }>;
+  validation_mode?: ValidationMode;
+  validation_agent?: string;
+  validation_fixture_id?: string;
+  validation_evidence_ref?: string;
 }
 
 export interface EvolutionEvidenceEntry {
@@ -697,6 +705,25 @@ export interface BodyEvolutionProposal {
 /** Closed union of gate names used in the validation pipeline. */
 export type ValidationGate = "structural" | "trigger_accuracy" | "quality";
 
+export type ValidationMode = "structural_guard" | "host_replay" | "llm_judge";
+
+export interface RoutingReplayFixture {
+  fixture_id: string;
+  platform: "claude_code" | "codex";
+  target_skill_name: string;
+  target_skill_path: string;
+  competing_skill_paths: string[];
+  workspace_root?: string;
+}
+
+export interface RoutingReplayEntryResult {
+  query: string;
+  should_trigger: boolean;
+  triggered: boolean;
+  passed: boolean;
+  evidence?: string;
+}
+
 /** Result of validating a body evolution proposal. */
 export interface BodyValidationResult {
   proposal_id: string;
@@ -705,6 +732,12 @@ export interface BodyValidationResult {
   gate_results: Array<{ gate: ValidationGate; passed: boolean; reason: string }>;
   improved: boolean;
   regressions: string[];
+  validation_mode?: ValidationMode;
+  validation_agent?: string;
+  validation_fixture_id?: string;
+  before_pass_rate?: number;
+  after_pass_rate?: number;
+  per_entry_results?: RoutingReplayEntryResult[];
 }
 
 /** Configuration for which LLM model a role should use. */
@@ -873,6 +906,26 @@ export interface SkillFamilyOverlapPair {
   consolidation_pressure: "low" | "medium" | "high";
 }
 
+export interface SkillFamilyColdStartPair {
+  skill_a: string;
+  skill_b: string;
+  description_similarity: number;
+  when_to_use_similarity: number;
+  shared_command_surfaces: string[];
+  shared_terms: string[];
+  synthetic_confusion_queries: string[];
+  suspicion_level: "low" | "medium" | "high";
+}
+
+export interface SkillFamilyColdStartSuspicion {
+  candidate: boolean;
+  analyzed_pairs: number;
+  suspicious_pair_count: number;
+  average_static_similarity: number;
+  pairs: SkillFamilyColdStartPair[];
+  rationale: string[];
+}
+
 export interface SkillFamilyRefactorWorkflow {
   workflow_name: string;
   source_skill: string;
@@ -892,6 +945,7 @@ export interface SkillFamilyOverlapReport {
   analyzed_skills: string[];
   members: SkillFamilyOverlapMember[];
   pairs: SkillFamilyOverlapPair[];
+  cold_start_suspicion?: SkillFamilyColdStartSuspicion;
   total_pairs_analyzed: number;
   overlap_count: number;
   overlap_density: number;

package/cli/selftune/utils/text-similarity.ts

@@ -0,0 +1,73 @@
+const BASE_TEXT_SIMILARITY_STOPWORDS = new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "for",
+  "from",
+  "how",
+  "in",
+  "into",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "this",
+  "to",
+  "use",
+  "user",
+  "when",
+  "with",
+]);
+
+export function buildStopwordSet(additionalStopwords: string[] = []): Set<string> {
+  return new Set([...BASE_TEXT_SIMILARITY_STOPWORDS, ...additionalStopwords]);
+}
+
+export function tokenizeText(
+  text: string,
+  stopwords = BASE_TEXT_SIMILARITY_STOPWORDS,
+): Set<string> {
+  return new Set(
+    text
+      .toLowerCase()
+      .split(/[^a-z0-9]+/i)
+      .map((token) => token.trim())
+      .filter((token) => token.length >= 3 && !stopwords.has(token)),
+  );
+}
+
+export function jaccardSimilarity(left: Set<string>, right: Set<string>): number {
+  if (left.size === 0 || right.size === 0) return 0;
+  let shared = 0;
+  for (const token of left) {
+    if (right.has(token)) shared += 1;
+  }
+  const union = left.size + right.size - shared;
+  return union > 0 ? shared / union : 0;
+}
+
+export function extractWhenToUseLines(body: string): string[] {
+  const lines = body.split("\n");
+  const start = lines.findIndex((line) => /^##+\s+when to use\s*$/i.test(line.trim()));
+  if (start === -1) return [];
+
+  const extracted: string[] = [];
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    if (/^##+\s+/.test(line)) break;
+    if (/^[-*]\s+/.test(line)) {
+      extracted.push(line.replace(/^[-*]\s+/, "").trim());
+      continue;
+    }
+    extracted.push(line);
+  }
+  return extracted;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "selftune",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "Self-improving skills CLI for AI agents",
   "keywords": [
     "agent",

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

@@ -12,6 +12,7 @@ import {
   ListChecksIcon,
 } from "lucide-react";
 import { useMemo, useState } from "react";
+import type { ReactNode } from "react";
 import Markdown from "react-markdown";
 
 import { formatRate, timeAgo } from "../lib/format";
@@ -34,6 +35,37 @@ interface Props {
   showContextBanner?: boolean;
 }
 
+function getValidationModeMeta(mode?: string | null): {
+  label: string;
+  variant: "default" | "secondary" | "destructive" | "outline";
+  description: string;
+} | null {
+  switch (mode) {
+    case "host_replay":
+      return {
+        label: "Replay-backed validation",
+        variant: "default",
+        description:
+          "Validated against a controlled replay fixture instead of a free-form judge prompt.",
+      };
+    case "llm_judge":
+      return {
+        label: "Model judgment",
+        variant: "secondary",
+        description: "Validated by an LLM trigger check rather than a replay fixture.",
+      };
+    case "structural_guard":
+      return {
+        label: "Structural guard",
+        variant: "outline",
+        description:
+          "Only deterministic structural checks ran; no replay or judge validation was needed.",
+      };
+    default:
+      return null;
+  }
+}
+
 function sentenceCase(value: string): string {
   return value.replace(/_/g, " ");
 }
@@ -42,7 +74,7 @@ function getOutcomePresentation(action?: string | null): {
   title: string;
   summary: string;
   tone: string;
-  icon: React.ReactNode;
+  icon: ReactNode;
   liveSkillNote: string;
 } {
   switch (action) {
@@ -180,7 +212,7 @@ function SkillContentBlock({
 }
 
 /** Smart formatting for a single validation value */
-function formatValidationValue(key: string, val: unknown): React.ReactNode {
+function formatValidationValue(key: string, val: unknown): ReactNode {
   // Booleans
   if (typeof val === "boolean") {
     return val ? (
@@ -279,12 +311,18 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
     regressions,
     new_passes,
     per_entry_results,
+    validation_mode,
+    validation_agent,
+    validation_fixture_id,
+    validation_evidence_ref,
     ...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 validationMeta =
+    typeof validation_mode === "string" ? getValidationModeMeta(validation_mode) : null;
 
   return (
     <div className="rounded-md border bg-muted/30 p-3 space-y-3">
@@ -295,6 +333,34 @@ function ValidationResults({ validation }: { validation: Record<string, unknown>
         </span>
       </p>
 
+      {validationMeta && (
+        <div className="rounded-md border bg-card px-3 py-2">
+          <div className="flex flex-wrap items-center gap-2">
+            <Badge variant={validationMeta.variant} className="text-[10px]">
+              {validationMeta.label}
+            </Badge>
+            {typeof validation_agent === "string" && validation_agent.trim() && (
+              <Badge variant="outline" className="text-[10px]">
+                agent: {validation_agent}
+              </Badge>
+            )}
+            {typeof validation_fixture_id === "string" && validation_fixture_id.trim() && (
+              <Badge variant="outline" className="text-[10px]">
+                fixture: {validation_fixture_id}
+              </Badge>
+            )}
+          </div>
+          <p className="mt-1 text-[11px] leading-relaxed text-muted-foreground">
+            {validationMeta.description}
+          </p>
+          {typeof validation_evidence_ref === "string" && validation_evidence_ref.trim() && (
+            <p className="mt-1 text-[10px] font-mono text-muted-foreground/70">
+              {validation_evidence_ref}
+            </p>
+          )}
+        </div>
+      )}
+
       {/* Summary bar */}
       <div className="flex items-center gap-3 flex-wrap">
         {improved !== undefined && (
@@ -730,6 +796,7 @@ export function EvidenceViewer({
   const latestStep = steps[steps.length - 1] ?? null;
   const lifecycleLabel = steps.map((step) => step.action.replace("_", " ")).join(" -> ");
   const outcome = getOutcomePresentation(latestStep?.action);
+  const validationMeta = getValidationModeMeta(latestStep?.validation_mode);
   const latestProposalConfidence = useMemo(() => {
     for (let i = proposalEntries.length - 1; i >= 0; i--) {
       if (proposalEntries[i].confidence !== null) {
@@ -824,6 +891,16 @@ export function EvidenceViewer({
             <Badge variant="outline" className="text-[10px]">
               {entries.length} evidence {entries.length === 1 ? "row" : "rows"}
             </Badge>
+            {validationMeta && (
+              <Badge variant={validationMeta.variant} className="text-[10px]">
+                {validationMeta.label}
+              </Badge>
+            )}
+            {latestStep?.validation_fixture_id && (
+              <Badge variant="outline" className="text-[10px]">
+                fixture: {latestStep.validation_fixture_id}
+              </Badge>
+            )}
             {latestProposalConfidence != null && (
               <Badge variant="secondary" className="text-[10px]">
                 {Math.round(latestProposalConfidence * 100)}% confidence
@@ -831,6 +908,12 @@ export function EvidenceViewer({
             )}
           </div>
 
+          {validationMeta && (
+            <p className="text-[11px] leading-relaxed text-muted-foreground">
+              {validationMeta.description}
+            </p>
+          )}
+
           <div className="flex flex-wrap items-center gap-2 text-[11px] text-muted-foreground">
             <span className="font-headline uppercase tracking-[0.16em] text-muted-foreground/80">
               Lifecycle

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

@@ -10,13 +10,14 @@ import {
   ChevronRightIcon,
 } from "lucide-react";
 import { useState } from "react";
+import type { ReactNode } from "react";
 
 import { timeAgo } from "../lib/format";
 import { cn } from "../lib/utils";
 import { Badge } from "../primitives/badge";
 import type { EvalSnapshot, EvolutionEntry } from "../types";
 
-const ACTION_ICON: Record<string, React.ReactNode> = {
+const ACTION_ICON: Record<string, ReactNode> = {
   created: <CircleDotIcon className="size-3.5" />,
   validated: <ShieldCheckIcon className="size-3.5" />,
   deployed: <RocketIcon className="size-3.5" />,
@@ -70,6 +71,21 @@ interface Props {
   onSelect: (proposalId: string) => void;
 }
 
+function validationModeBadge(
+  mode?: string | null,
+): { label: string; variant: "default" | "secondary" | "outline" } | null {
+  switch (mode) {
+    case "host_replay":
+      return { label: "replay", variant: "default" };
+    case "llm_judge":
+      return { label: "judge", variant: "secondary" };
+    case "structural_guard":
+      return { label: "structural", variant: "outline" };
+    default:
+      return null;
+  }
+}
+
 /** Group evolution entries by proposal_id, ordered newest-first. */
 function groupByProposal(entries: EvolutionEntry[]) {
   const map = new Map<string, EvolutionEntry[]>();
@@ -201,6 +217,7 @@ export function EvolutionTimeline({ entries, selectedProposalId, onSelect }: Pro
           const lineColor = ACTION_LINE[terminal] ?? "bg-border";
           const isLast = groupIdx === groups.length - 1;
           const snapshot = findEvalSnapshot(steps);
+          const validationBadge = validationModeBadge(lastStep.validation_mode);
 
           return (
             <div key={proposalId} className="relative flex gap-3">
@@ -245,6 +262,11 @@ export function EvolutionTimeline({ entries, selectedProposalId, onSelect }: Pro
                   <span className="text-[10px] text-muted-foreground">
                     {timeAgo(lastStep.timestamp)}
                   </span>
+                  {validationBadge && (
+                    <Badge variant={validationBadge.variant} className="text-[9px] uppercase">
+                      {validationBadge.label}
+                    </Badge>
+                  )}
                 </div>
                 {/* Pass rate delta from eval snapshot */}
                 {snapshot && (