@kairos-sdk/core 0.3.1 → 0.4.0

package/dist/cli.cjs

@@ -524,17 +524,28 @@ var N8nValidator = class {
     this.checkRule21(workflow, issues);
     this.checkRule22(workflow, issues);
     this.checkRule23(workflow, issues);
+    if (Array.isArray(workflow.nodes)) {
+      const nodeById = new Map(workflow.nodes.map((n) => [n.id, n.type]));
+      for (const issue of issues) {
+        if (issue.nodeId && !issue.nodeType) {
+          const nt = nodeById.get(issue.nodeId);
+          if (nt) issue.nodeType = nt;
+        }
+      }
+    }
     const errors = issues.filter((i) => i.severity === "error");
     return { valid: errors.length === 0, issues };
   }
-  err(issues, rule, message, nodeId) {
+  err(issues, rule, message, nodeId, nodeType) {
     const issue = { rule, severity: "error", message };
     if (nodeId !== void 0) issue.nodeId = nodeId;
+    if (nodeType !== void 0) issue.nodeType = nodeType;
     issues.push(issue);
   }
-  warn(issues, rule, message, nodeId) {
+  warn(issues, rule, message, nodeId, nodeType) {
     const issue = { rule, severity: "warn", message };
     if (nodeId !== void 0) issue.nodeId = nodeId;
+    if (nodeType !== void 0) issue.nodeType = nodeType;
     issues.push(issue);
   }
   isTriggerNode(node) {
@@ -897,14 +908,23 @@ var ResponseParseError = class extends KairosError {
 
 // src/errors/validation-error.ts
 var ValidationError = class extends KairosError {
-  constructor(message, issues) {
+  constructor(message, issues, attemptMetadata, warnedRules) {
     super(message);
     this.issues = issues;
+    this.attemptMetadata = attemptMetadata;
+    this.warnedRules = warnedRules;
     this.name = "ValidationError";
   }
   issues;
+  attemptMetadata;
+  warnedRules;
 };
 
+// src/generation/prompt-builder.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+
 // src/generation/prompts/v1.ts
 var SYSTEM_PROMPT_V1 = `You are a workflow generation engine for n8n. Your only output is a generate_workflow tool call containing valid n8n workflow JSON. You never respond with prose, explanations, or markdown. If you cannot fulfill the request, set the error field in the tool call.
 
@@ -1097,8 +1117,34 @@ function scoreToMode(score) {
   return "scratch";
 }
 
-// src/generation/prompt-builder.ts
-var RULE_REMEDIES = {
+// src/validation/rule-metadata.ts
+var VALIDATOR_RULE_IDS = Array.from({ length: 23 }, (_, i) => i + 1);
+var RULE_PIPELINE_STAGES = {
+  1: "node_generation",
+  2: "node_generation",
+  3: "node_generation",
+  4: "node_generation",
+  5: "node_generation",
+  6: "node_generation",
+  7: "node_generation",
+  8: "node_generation",
+  9: "connection_wiring",
+  10: "connection_wiring",
+  11: "connection_wiring",
+  12: "workflow_structure",
+  13: "node_generation",
+  14: "workflow_structure",
+  15: "node_generation",
+  16: "node_generation",
+  17: "credential_injection",
+  18: "connection_wiring",
+  19: "node_generation",
+  20: "connection_wiring",
+  21: "workflow_structure",
+  22: "workflow_structure",
+  23: "node_generation"
+};
+var RULE_MITIGATIONS = {
   1: "Provide a non-empty workflow name string",
   2: "Include at least one node in the nodes array",
   3: "Every node must have a unique UUID v4 string as its id field",
@@ -1109,8 +1155,10 @@ var RULE_REMEDIES = {
   8: "Every node must have a non-empty name string",
   9: "connections must be a plain object (use {} if no connections)",
   10: "Every node name in connections (source and target) must exactly match a name in the nodes array",
+  11: "Every non-trigger node should have at least one incoming connection",
   12: "Remove forbidden fields: id, active, createdAt, updatedAt, versionId, meta, tags \u2014 these are server-assigned",
-  14: "Include at least one trigger node (e.g. webhook, scheduleTrigger, manualTrigger)",
+  13: "workflow.settings must be a plain object if present",
+  14: "Include at least one trigger node (e.g. scheduleTrigger, webhookTrigger, manualTrigger, or service-specific)",
   15: 'Node type strings must be fully qualified: "n8n-nodes-base.httpRequest" not just "httpRequest"',
   16: "All node names must be unique within the workflow",
   17: 'Credentials must be an object with non-empty string id and name fields: { id: "placeholder-id", name: "My Credential" }',
@@ -1118,9 +1166,17 @@ var RULE_REMEDIES = {
   19: "Use known safe typeVersion values for each node type",
   20: "Remove connection cycles \u2014 ensure no node can reach itself through the connection graph",
   21: 'When using webhook with responseMode "responseNode", include a respondToWebhook node in the flow',
-  22: "Ensure all required parameters are set for each node type (e.g. webhook needs httpMethod and path)"
+  22: "Ensure all required parameters are set for each node type (e.g. webhook needs httpMethod and path)",
+  23: "Use node types that exist in the n8n registry \u2014 check with kairos_sync"
 };
+
+// src/generation/prompt-builder.ts
+var CRITICAL_SCORE_THRESHOLD = 0.15;
 var PromptBuilder = class {
+  patternsPath;
+  constructor(patternsPath) {
+    this.patternsPath = patternsPath ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".kairos", "patterns.json");
+  }
   build(request, matches, globalFailureRates = [], dynamicCatalog) {
     const mode = this.resolveMode(matches);
     const system = this.buildSystem(matches, mode, globalFailureRates, dynamicCatalog);
@@ -1206,20 +1262,114 @@ A loosely similar workflow (score: ${hint.score.toFixed(2)}) used these node typ
     }
     return blocks;
   }
+  loadPatterns() {
+    try {
+      const raw = (0, import_node_fs.readFileSync)(this.patternsPath, "utf-8");
+      const analysis = JSON.parse(raw);
+      const patterns = analysis.topFailureRules ?? [];
+      return patterns.filter((p) => typeof p.pipelineStage === "string" && typeof p.state === "string");
+    } catch {
+      return [];
+    }
+  }
+  getWarnedRules() {
+    return this.getActivePatterns().map((p) => p.rule);
+  }
+  getActivePatterns() {
+    const MAX_WARNED = 10;
+    const all = this.loadPatterns().filter((p) => p.state !== "resolved" && p.confidence > 0);
+    const regressed = all.filter((p) => p.regressed).sort((a, b) => b.compositeScore - a.compositeScore);
+    const confirmed = all.filter((p) => !p.regressed && p.state === "confirmed").sort((a, b) => b.compositeScore - a.compositeScore);
+    const drafts = all.filter((p) => !p.regressed && p.state !== "confirmed").sort((a, b) => b.compositeScore - a.compositeScore);
+    return [...regressed, ...confirmed, ...drafts].slice(0, MAX_WARNED);
+  }
   buildFailureWarnings(matches, globalFailureRates) {
+    const richPatterns = this.getActivePatterns();
+    if (richPatterns.length > 0) {
+      return this.buildStageGroupedWarnings(richPatterns, matches);
+    }
+    return this.buildLegacyWarnings(matches, globalFailureRates);
+  }
+  buildStageGroupedWarnings(patterns, matches) {
+    const stageLabels = {
+      credential_injection: "CREDENTIAL FORMATTING",
+      connection_wiring: "CONNECTION WIRING",
+      node_generation: "NODE GENERATION",
+      workflow_structure: "WORKFLOW STRUCTURE"
+    };
+    const byStage = /* @__PURE__ */ new Map();
+    for (const p of patterns) {
+      const list = byStage.get(p.pipelineStage) ?? [];
+      list.push(p);
+      byStage.set(p.pipelineStage, list);
+    }
+    const sections = [];
+    for (const [stage, stagePatterns] of byStage) {
+      const label = stageLabels[stage] ?? stage;
+      const byMitigation = /* @__PURE__ */ new Map();
+      for (const p of stagePatterns) {
+        const key = p.mitigation ?? `rule_${p.rule}`;
+        const list = byMitigation.get(key) ?? [];
+        list.push(p);
+        byMitigation.set(key, list);
+      }
+      const lines = [];
+      for (const group of byMitigation.values()) {
+        if (group.length === 1) {
+          const p = group[0];
+          const urgency = p.regressed ? "CRITICAL REGRESSION: " : (p.compositeScore ?? 0) >= CRITICAL_SCORE_THRESHOLD ? "CRITICAL: " : "";
+          const statePrefix = p.state === "confirmed" ? "[CONFIRMED] " : "";
+          const trendSuffix = p.trend === "worsening" ? " (GETTING WORSE)" : p.trend === "improving" ? " (improving)" : "";
+          const remedy = p.mitigation ?? RULE_MITIGATIONS[p.rule];
+          const remedyStr = remedy ? `
+  Fix: ${remedy}` : "";
+          lines.push(`- ${urgency}${statePrefix}Rule ${p.rule}${trendSuffix}: ${p.exampleMessages[0] ?? "No example"}${remedyStr}`);
+        } else {
+          const ruleNums = group.map((p) => p.rule).join(", ");
+          const totalFailures = group.reduce((s, p) => s + p.failureCount, 0);
+          const hasConfirmed = group.some((p) => p.state === "confirmed");
+          const statePrefix = hasConfirmed ? "[CONFIRMED] " : "";
+          const remedy = group[0].mitigation;
+          const remedyStr = remedy ? `
+  Fix: ${remedy}` : "";
+          lines.push(`- ${statePrefix}Rules ${ruleNums} (${totalFailures} failures combined): same root cause${remedyStr}`);
+        }
+      }
+      sections.push(`### ${label}
+${lines.join("\n")}`);
+    }
+    for (const match of matches) {
+      const fps = match.workflow.failurePatterns;
+      if (!fps?.length) continue;
+      const coveredRules = new Set(patterns.map((p) => p.rule));
+      const extra = fps.filter((fp) => !coveredRules.has(fp.rule));
+      for (const fp of extra) {
+        const remedy = RULE_MITIGATIONS[fp.rule];
+        const remedyStr = remedy ? ` \u2014 Fix: ${remedy}` : "";
+        sections.push(`- Rule ${fp.rule}: "${fp.message}"${remedyStr} (seen in similar workflows)`);
+      }
+    }
+    if (sections.length === 0) return null;
+    return `## Known Failure Patterns \u2014 AVOID THESE
+
+Grouped by generation stage. Fix these BEFORE outputting your response:
+
+${sections.join("\n\n")}`;
+  }
+  buildLegacyWarnings(matches, globalFailureRates) {
     const lines = [];
     for (const match of matches) {
       const patterns = match.workflow.failurePatterns;
       if (!patterns?.length) continue;
       for (const fp of patterns) {
-        const remedy = RULE_REMEDIES[fp.rule];
+        const remedy = RULE_MITIGATIONS[fp.rule];
         const remedyStr = remedy ? ` \u2014 Fix: ${remedy}` : "";
         lines.push(`- Rule ${fp.rule}: "${fp.message}"${remedyStr} (seen ${fp.occurrences}x in similar workflows)`);
       }
     }
     const highFreqRules = globalFailureRates.filter((r) => r.rate >= 0.15);
     for (const rule of highFreqRules) {
-      const remedy = RULE_REMEDIES[rule.rule];
+      const remedy = RULE_MITIGATIONS[rule.rule];
       const remedyStr = remedy ? ` \u2014 Fix: ${remedy}` : "";
       lines.push(`- Rule ${rule.rule}: "${rule.commonMessage}"${remedyStr} (fails in ${Math.round(rule.rate * 100)}% of all builds)`);
     }
@@ -1330,7 +1480,7 @@ var WorkflowDesigner = class {
         issues: validation.issues
       });
       if (validation.valid) {
-        return { workflow: parsed.workflow, credentialsNeeded: parsed.credentialsNeeded, attempts, attemptMetadata };
+        return { workflow: parsed.workflow, credentialsNeeded: parsed.credentialsNeeded, attempts, attemptMetadata, warnedRules: this.promptBuilder.getWarnedRules() };
       }
       lastErrors = errors;
       this.logger.warn(`WorkflowDesigner: validation failed on attempt ${attempt}`, {
@@ -1340,7 +1490,9 @@ var WorkflowDesigner = class {
     const finalIssues = attemptMetadata.at(-1)?.issues ?? lastErrors;
     throw new ValidationError(
       `Workflow failed validation after ${MAX_ATTEMPTS} attempts`,
-      finalIssues
+      finalIssues,
+      attemptMetadata,
+      this.promptBuilder.getWarnedRules()
     );
   }
   async callClaude(system, userMessage, temperature) {
@@ -1394,8 +1546,8 @@ var WorkflowDesigner = class {
 
 // src/telemetry/collector.ts
 var import_promises = require("fs/promises");
-var import_node_path = require("path");
-var import_node_os = require("os");
+var import_node_path2 = require("path");
+var import_node_os2 = require("os");
 
 // src/telemetry/types.ts
 var TELEMETRY_SCHEMA_VERSION = 2;
@@ -1406,7 +1558,7 @@ var TelemetryCollector = class {
   sessionId;
   dirReady = null;
   constructor(dir) {
-    this.dir = dir ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".kairos", "telemetry");
+    this.dir = dir ?? (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".kairos", "telemetry");
     this.sessionId = generateUUID();
   }
   async emit(eventType, data) {
@@ -1423,21 +1575,61 @@ var TelemetryCollector = class {
     }
     await this.dirReady;
     const filename = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ".jsonl";
-    const filepath = (0, import_node_path.join)(this.dir, filename);
+    const filepath = (0, import_node_path2.join)(this.dir, filename);
     await (0, import_promises.appendFile)(filepath, JSON.stringify(event) + "\n", "utf-8");
   }
 };
 
 // src/telemetry/reader.ts
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+
+// src/telemetry/event-reader.ts
 var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
-var import_node_os2 = require("os");
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var import_node_readline = require("readline");
+async function readTelemetryEvents(dir, days) {
+  let files;
+  try {
+    files = await (0, import_promises2.readdir)(dir);
+  } catch {
+    return [];
+  }
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+  const cutoffStr = cutoff.toISOString().slice(0, 10);
+  const todayStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const datePattern = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+  const recentFiles = files.filter((f) => datePattern.test(f) && f >= cutoffStr && f <= `${todayStr}.jsonl`).sort();
+  const events = [];
+  for (const file of recentFiles) {
+    const fileDate = file.replace(".jsonl", "");
+    try {
+      const rl = (0, import_node_readline.createInterface)({
+        input: (0, import_node_fs2.createReadStream)((0, import_node_path3.join)(dir, file), "utf-8"),
+        crlfDelay: Infinity
+      });
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        try {
+          events.push({ ...JSON.parse(line), fileDate });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return events;
+}
+
+// src/telemetry/reader.ts
 var TelemetryReader = class {
   dir;
   cache = null;
   cacheTime = 0;
   constructor(dir) {
-    this.dir = dir ?? (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".kairos", "telemetry");
+    this.dir = dir ?? (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".kairos", "telemetry");
   }
   async getFailureRates(days = 30) {
     const now = Date.now();
@@ -1446,9 +1638,10 @@ var TelemetryReader = class {
     }
     const events = await this.readRecentEvents(days);
     const buildSessions = new Set(
-      events.filter((e) => e.eventType === "build_complete" && !e.data.dryRun).map((e) => e.sessionId)
+      events.filter((e) => e.eventType === "build_complete").map((e) => e.sessionId)
     );
-    if (buildSessions.size === 0) return [];
+    const MIN_BUILDS_FOR_RATES = 3;
+    if (buildSessions.size < MIN_BUILDS_FOR_RATES) return [];
     const ruleSessions = /* @__PURE__ */ new Map();
     for (const event of events) {
       if (event.eventType !== "generation_attempt") continue;
@@ -1486,32 +1679,425 @@ var TelemetryReader = class {
     return rates;
   }
   async readRecentEvents(days) {
-    let files;
+    return readTelemetryEvents(this.dir, days);
+  }
+};
+
+// src/telemetry/pattern-analyzer.ts
+var import_promises3 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_node_os4 = require("os");
+var PATTERN_SCHEMA_VERSION = 2;
+var PatternAnalyzer = class _PatternAnalyzer {
+  telemetryDir;
+  outputDir;
+  constructor(telemetryDir) {
+    const defaultDir = (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".kairos", "telemetry");
+    this.telemetryDir = telemetryDir ?? defaultDir;
+    this.outputDir = telemetryDir ? (0, import_node_path5.join)(telemetryDir, "..") : (0, import_node_path5.join)((0, import_node_os4.homedir)(), ".kairos");
+  }
+  async loadPreviousPatterns() {
     try {
-      files = await (0, import_promises2.readdir)(this.dir);
+      const raw = await (0, import_promises3.readFile)((0, import_node_path5.join)(this.outputDir, "patterns.json"), "utf-8");
+      const prev = JSON.parse(raw);
+      const version = prev.schemaVersion ?? 0;
+      const patterns = prev.topFailureRules ?? [];
+      if (version === PATTERN_SCHEMA_VERSION) return patterns;
+      return this.migratePatterns(patterns, version);
     } catch {
       return [];
     }
-    const cutoff = /* @__PURE__ */ new Date();
-    cutoff.setDate(cutoff.getDate() - days);
-    const cutoffStr = cutoff.toISOString().slice(0, 10);
-    const datePattern = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
-    const recentFiles = files.filter((f) => datePattern.test(f) && f >= cutoffStr).sort();
-    const events = [];
-    for (const file of recentFiles) {
-      try {
-        const content = await (0, import_promises2.readFile)((0, import_node_path2.join)(this.dir, file), "utf-8");
-        for (const line of content.split("\n")) {
-          if (!line.trim()) continue;
-          try {
-            events.push(JSON.parse(line));
-          } catch {
+  }
+  migratePatterns(patterns, fromVersion) {
+    let migrated = patterns;
+    if (fromVersion < 1) {
+      migrated = migrated.map((p) => ({
+        ...p,
+        compositeScore: p.compositeScore ?? 0,
+        scoringFactors: p.scoringFactors ?? { rawConfidence: 0, impact: 0, recency: 0, stickinessBoost: 0 },
+        pipelineStage: p.pipelineStage ?? "node_generation"
+      }));
+    }
+    if (fromVersion < 2) {
+      migrated = migrated.map((p) => ({
+        ...p,
+        scoringFactors: {
+          ...p.scoringFactors,
+          stickinessBoost: p.scoringFactors.stickinessBoost ?? p.scoringFactors["validationBoost"] ?? 0
+        }
+      }));
+    }
+    return migrated;
+  }
+  async analyze(days = 30) {
+    const previousPatterns = await this.loadPreviousPatterns();
+    const events = await this.readAllEvents(days);
+    const starts = events.filter((e) => e.eventType === "build_start");
+    const attempts = events.filter((e) => e.eventType === "generation_attempt");
+    const passed = attempts.filter(
+      (a) => a.data.validationPassed === true
+    );
+    const failed = attempts.filter(
+      (a) => a.data.validationPassed === false
+    );
+    const ruleFailures = /* @__PURE__ */ new Map();
+    const credentialFailures = /* @__PURE__ */ new Map();
+    for (const a of failed) {
+      const weight = this.recencyWeight(a.fileDate);
+      const data = a.data;
+      for (const issue of data.issues ?? []) {
+        const entry = ruleFailures.get(issue.rule) ?? { count: 0, sessions: /* @__PURE__ */ new Set(), recencyWeights: [], allMessages: [] };
+        entry.count++;
+        entry.sessions.add(a.sessionId);
+        entry.recencyWeights.push(weight);
+        entry.allMessages.push(issue.message);
+        ruleFailures.set(issue.rule, entry);
+        if (issue.rule === 17) {
+          const credPatterns = [
+            /credential\s+"([^"]+)"/,
+            /credentialType[:\s]+"?([^"'\s]+)"?/,
+            /missing\s+credential\s+(?:for\s+)?["']?([^"'\s]+)/i
+          ];
+          let credType = "unknown";
+          for (const re of credPatterns) {
+            const m = issue.message.match(re);
+            if (m?.[1]) {
+              credType = m[1];
+              break;
+            }
           }
+          credentialFailures.set(credType, (credentialFailures.get(credType) ?? 0) + 1);
         }
-      } catch {
       }
     }
-    return events;
+    const failedByDate = /* @__PURE__ */ new Map();
+    for (const a of failed) {
+      failedByDate.set(a.fileDate, (failedByDate.get(a.fileDate) ?? 0) + 1);
+    }
+    const sortedFailDates = [...failedByDate.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    const hasTrendData = sortedFailDates.length >= 3;
+    let midDate = "";
+    if (hasTrendData) {
+      const halfTotal = failed.length / 2;
+      let cumulative = 0;
+      for (const [date, count] of sortedFailDates) {
+        cumulative += count;
+        if (cumulative >= halfTotal) {
+          midDate = date;
+          break;
+        }
+      }
+    }
+    const ruleTrends = /* @__PURE__ */ new Map();
+    if (hasTrendData) {
+      for (const a of failed) {
+        const data = a.data;
+        const isNewer = a.fileDate > midDate;
+        for (const issue of data.issues ?? []) {
+          const entry = ruleTrends.get(issue.rule) ?? { older: 0, newer: 0 };
+          if (isNewer) entry.newer++;
+          else entry.older++;
+          ruleTrends.set(issue.rule, entry);
+        }
+      }
+    }
+    const sessions = /* @__PURE__ */ new Map();
+    for (const a of attempts) {
+      const list = sessions.get(a.sessionId) ?? [];
+      list.push(a);
+      sessions.set(a.sessionId, list);
+    }
+    let firstTryPass = 0;
+    let correctionNeeded = 0;
+    let singleAttemptFail = 0;
+    for (const sessionAttempts of sessions.values()) {
+      const lastAttempt = sessionAttempts[sessionAttempts.length - 1];
+      const lastPassed = lastAttempt.data.validationPassed === true;
+      if (sessionAttempts.length === 1 && lastPassed) {
+        firstTryPass++;
+      } else if (sessionAttempts.length > 1 && lastPassed) {
+        correctionNeeded++;
+      } else {
+        singleAttemptFail++;
+      }
+    }
+    const durations = attempts.map((a) => a.data.durationMs).filter((d) => typeof d === "number" && d > 0);
+    const avgDuration = durations.length > 0 ? durations.reduce((s, d) => s + d, 0) / durations.length : 0;
+    const totalInput = attempts.reduce((s, a) => s + (a.data.tokensInput ?? 0), 0);
+    const totalOutput = attempts.reduce((s, a) => s + (a.data.tokensOutput ?? 0), 0);
+    const totalSessions = Math.max(sessions.size, 1);
+    const stickinessCount = /* @__PURE__ */ new Map();
+    for (const sessionAttempts of sessions.values()) {
+      if (sessionAttempts.length < 2) continue;
+      for (let i = 0; i < sessionAttempts.length - 1; i++) {
+        const curr = sessionAttempts[i].data;
+        const next = sessionAttempts[i + 1].data;
+        if (curr.validationPassed !== false || next.validationPassed !== false) continue;
+        const currRules = new Set((curr.issues ?? []).map((iss) => iss.rule));
+        const nextRules = new Set((next.issues ?? []).map((iss) => iss.rule));
+        for (const rule of currRules) {
+          if (nextRules.has(rule)) {
+            stickinessCount.set(rule, (stickinessCount.get(rule) ?? 0) + 1);
+          }
+        }
+      }
+    }
+    const CONFIRMED_THRESHOLD = 3;
+    const BUILDS_SINCE_LAST_FAILURE_THRESHOLD = 5;
+    const RESOLVED_TTL_DAYS = 90;
+    const activePatterns = [...ruleFailures.entries()].map(([rule, entry]) => {
+      const t = ruleTrends.get(rule) ?? { older: 0, newer: 0 };
+      const rawConfidence = Math.min(entry.sessions.size / totalSessions, 1);
+      const state = entry.count >= CONFIRMED_THRESHOLD ? "confirmed" : "draft";
+      const avgRecency = entry.recencyWeights.length > 0 ? entry.recencyWeights.reduce((s, w) => s + w, 0) / entry.recencyWeights.length : 1;
+      const stickiness = stickinessCount.get(rule) ?? 0;
+      const { compositeScore, factors } = this.computeCompositeScore(rawConfidence, entry.count, state, avgRecency, stickiness);
+      return {
+        rule,
+        failureCount: entry.count,
+        confidence: Math.round(rawConfidence * 1e3) / 1e3,
+        compositeScore,
+        scoringFactors: factors,
+        state,
+        trend: this.classifyTrend(t.older, t.newer),
+        pipelineStage: RULE_PIPELINE_STAGES[rule] ?? "node_generation",
+        exampleMessages: this.deduplicateMessages(entry.allMessages),
+        mitigation: RULE_MITIGATIONS[rule] ?? null
+      };
+    }).sort((a, b) => b.compositeScore - a.compositeScore);
+    const activeRules = new Set(activePatterns.map((p) => p.rule));
+    for (const p of activePatterns) {
+      const prev = previousPatterns.find((pp) => pp.rule === p.rule);
+      if (prev?.state === "resolved") {
+        p.trend = "worsening";
+        p.regressed = true;
+      }
+    }
+    const ruleLastFailureDate = /* @__PURE__ */ new Map();
+    for (const a of failed) {
+      const data = a.data;
+      for (const issue of data.issues ?? []) {
+        const existing = ruleLastFailureDate.get(issue.rule);
+        if (!existing || a.fileDate > existing) {
+          ruleLastFailureDate.set(issue.rule, a.fileDate);
+        }
+      }
+    }
+    const newlyResolved = previousPatterns.filter((p) => {
+      if (p.state !== "confirmed" || activeRules.has(p.rule)) return false;
+      const lastFailDate = ruleLastFailureDate.get(p.rule) ?? "";
+      const buildsSince = starts.filter((s) => s.fileDate > lastFailDate).length;
+      return buildsSince >= BUILDS_SINCE_LAST_FAILURE_THRESHOLD;
+    }).map((p) => ({
+      ...p,
+      state: "resolved",
+      trend: "improving",
+      pipelineStage: p.pipelineStage ?? RULE_PIPELINE_STAGES[p.rule] ?? "node_generation",
+      confidence: 0,
+      compositeScore: 0,
+      scoringFactors: { rawConfidence: 0, impact: 0, recency: 0, stickinessBoost: 0 },
+      failureCount: 0,
+      resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    const ttlCutoff = /* @__PURE__ */ new Date();
+    ttlCutoff.setDate(ttlCutoff.getDate() - RESOLVED_TTL_DAYS);
+    const ttlCutoffStr = ttlCutoff.toISOString();
+    const carriedResolved = previousPatterns.filter((p) => p.state === "resolved" && !activeRules.has(p.rule) && (!p.resolvedAt || p.resolvedAt >= ttlCutoffStr)).map((p) => ({ ...p }));
+    const newlyResolvedRules = new Set(newlyResolved.map((p) => p.rule));
+    const pendingResolution = previousPatterns.filter((p) => p.state === "confirmed" && !activeRules.has(p.rule) && !newlyResolvedRules.has(p.rule)).map((p) => ({ ...p }));
+    const deduped = [
+      ...newlyResolved,
+      ...carriedResolved.filter((p) => !newlyResolvedRules.has(p.rule)),
+      ...pendingResolution
+    ];
+    const patterns = [...activePatterns, ...deduped];
+    const credTypes = [...credentialFailures.entries()].sort((a, b) => b[1] - a[1]).map(([type, count]) => ({ type, count }));
+    const drift = this.detectDrift(patterns);
+    const warnEffMap = /* @__PURE__ */ new Map();
+    const buildCompletes = events.filter((e) => e.eventType === "build_complete");
+    for (const bc of buildCompletes) {
+      const bcData = bc.data;
+      const warned = bcData.warnedRules ?? [];
+      if (warned.length === 0) continue;
+      const sessionFailedRules = /* @__PURE__ */ new Set();
+      const sessionAttempts = sessions.get(bc.sessionId) ?? [];
+      for (const a of sessionAttempts) {
+        const ad = a.data;
+        if (ad.validationPassed === false) {
+          for (const issue of ad.issues ?? []) {
+            sessionFailedRules.add(issue.rule);
+          }
+        }
+      }
+      for (const rule of warned) {
+        const entry = warnEffMap.get(rule) ?? { warned: 0, passed: 0, failed: 0 };
+        entry.warned++;
+        if (sessionFailedRules.has(rule)) entry.failed++;
+        else entry.passed++;
+        warnEffMap.set(rule, entry);
+      }
+    }
+    const warningEffectiveness = [...warnEffMap.entries()].map(([rule, e]) => ({
+      rule,
+      timesWarned: e.warned,
+      timesWarnedAndPassed: e.passed,
+      timesWarnedAndFailed: e.failed,
+      effectivenessRate: e.warned > 0 ? Math.round(e.passed / e.warned * 1e3) / 1e3 : 0
+    })).sort((a, b) => b.timesWarned - a.timesWarned);
+    const coOccurrenceMap = /* @__PURE__ */ new Map();
+    for (const a of failed) {
+      const data = a.data;
+      const rules = [...new Set((data.issues ?? []).map((i) => i.rule))].sort((x, y) => x - y);
+      for (let i = 0; i < rules.length; i++) {
+        for (let j = i + 1; j < rules.length; j++) {
+          const key = `${rules[i]},${rules[j]}`;
+          coOccurrenceMap.set(key, (coOccurrenceMap.get(key) ?? 0) + 1);
+        }
+      }
+    }
+    const ruleCoOccurrence = [...coOccurrenceMap.entries()].filter(([, count]) => count >= 3).map(([key, count]) => {
+      const [a, b] = key.split(",").map(Number);
+      return { rules: [a, b], count };
+    }).sort((a, b) => b.count - a.count);
+    const attemptDistribution = {};
+    for (const sessionAttempts of sessions.values()) {
+      const depth = sessionAttempts.length;
+      attemptDistribution[depth] = (attemptDistribution[depth] ?? 0) + 1;
+    }
+    return {
+      schemaVersion: PATTERN_SCHEMA_VERSION,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      summary: {
+        totalBuilds: starts.length,
+        totalAttempts: attempts.length,
+        firstTryPassRate: Math.round(firstTryPass / totalSessions * 1e3) / 1e3,
+        correctionRate: Math.round(correctionNeeded / totalSessions * 1e3) / 1e3,
+        singleAttemptFailRate: Math.round(singleAttemptFail / totalSessions * 1e3) / 1e3,
+        avgDurationMs: Math.round(avgDuration),
+        totalTokensInput: totalInput,
+        totalTokensOutput: totalOutput,
+        attemptDistribution
+      },
+      topFailureRules: patterns,
+      failingCredentialTypes: credTypes,
+      drift,
+      warningEffectiveness,
+      ruleCoOccurrence
+    };
+  }
+  async analyzeAndSave(days = 30) {
+    const analysis = await this.analyze(days);
+    await (0, import_promises3.mkdir)(this.outputDir, { recursive: true });
+    const outputPath = (0, import_node_path5.join)(this.outputDir, "patterns.json");
+    const tmpPath = `${outputPath}.tmp`;
+    await (0, import_promises3.writeFile)(tmpPath, JSON.stringify(analysis, null, 2), "utf-8");
+    await (0, import_promises3.rename)(tmpPath, outputPath);
+    const historySummary = {
+      timestamp: analysis.generatedAt,
+      totalBuilds: analysis.summary.totalBuilds,
+      firstTryPassRate: analysis.summary.firstTryPassRate,
+      correctionRate: analysis.summary.correctionRate,
+      singleAttemptFailRate: analysis.summary.singleAttemptFailRate,
+      activePatternCount: analysis.topFailureRules.filter((p) => p.state !== "resolved").length,
+      topRules: analysis.topFailureRules.filter((p) => p.state !== "resolved").slice(0, 5).map((p) => ({ rule: p.rule, compositeScore: p.compositeScore, state: p.state }))
+    };
+    const historyPath = (0, import_node_path5.join)(this.outputDir, "pattern-history.jsonl");
+    await (0, import_promises3.appendFile)(historyPath, JSON.stringify(historySummary) + "\n", "utf-8");
+    return analysis;
+  }
+  async getHistory(limit = 20) {
+    try {
+      const raw = await (0, import_promises3.readFile)((0, import_node_path5.join)(this.outputDir, "pattern-history.jsonl"), "utf-8");
+      return raw.trim().split("\n").filter(Boolean).map((l) => JSON.parse(l)).slice(-limit);
+    } catch {
+      return [];
+    }
+  }
+  static fromEnv() {
+    const dir = process.env["KAIROS_TELEMETRY"];
+    return dir && dir !== "true" && dir !== "false" ? new _PatternAnalyzer(dir) : new _PatternAnalyzer();
+  }
+  detectDrift(patterns) {
+    const VALIDATOR_RULES = VALIDATOR_RULE_IDS;
+    const validatorRuleSet = new Set(VALIDATOR_RULES);
+    const alerts = [];
+    for (const p of patterns) {
+      if (p.state !== "resolved" && !validatorRuleSet.has(p.rule)) {
+        alerts.push({
+          type: "stale_pattern",
+          rule: p.rule,
+          message: `Pattern references Rule ${p.rule} which does not exist in the current validator (rules 1-23)`
+        });
+      }
+    }
+    for (const rule of VALIDATOR_RULES) {
+      if (!(rule in RULE_MITIGATIONS)) {
+        alerts.push({
+          type: "missing_mitigation",
+          rule,
+          message: `Rule ${rule} has no mitigation text \u2014 if it fails, the system can't advise the LLM how to fix it`
+        });
+      }
+      if (!(rule in RULE_PIPELINE_STAGES)) {
+        alerts.push({
+          type: "missing_stage_mapping",
+          rule,
+          message: `Rule ${rule} has no pipeline stage mapping \u2014 failures won't be grouped correctly`
+        });
+      }
+    }
+    const coveredRules = VALIDATOR_RULES.filter((r) => r in RULE_MITIGATIONS && r in RULE_PIPELINE_STAGES).length;
+    return {
+      healthy: alerts.length === 0,
+      alerts,
+      coveredRules,
+      totalRules: VALIDATOR_RULES.length
+    };
+  }
+  computeCompositeScore(rawConfidence, sampleSize, state, avgRecency, stickiness) {
+    const stateWeights = { draft: 0.3, confirmed: 0.8, resolved: 0.1 };
+    const stateWeight = stateWeights[state];
+    const impact = (1 - Math.exp(-sampleSize / 5)) * stateWeight;
+    const stickinessBoost = Math.min(0.15, stickiness * 0.05);
+    const compositeScore = Math.min(Math.round(rawConfidence * impact * avgRecency * (1 + stickinessBoost) * 1e3) / 1e3, 1);
+    return {
+      compositeScore,
+      factors: {
+        rawConfidence: Math.round(rawConfidence * 1e3) / 1e3,
+        impact: Math.round(impact * 1e3) / 1e3,
+        recency: Math.round(avgRecency * 1e3) / 1e3,
+        stickinessBoost: Math.round(stickinessBoost * 1e3) / 1e3
+      }
+    };
+  }
+  classifyTrend(older, newer) {
+    const total = older + newer;
+    if (total === 0) return "stable";
+    if (older === 0) return "new";
+    const newerRatio = newer / total;
+    if (newerRatio >= 0.65) return "worsening";
+    if (newerRatio <= 0.35) return "improving";
+    return "stable";
+  }
+  deduplicateMessages(messages, maxCount = 3) {
+    const normalize = (msg) => msg.replace(/[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}/gi, "...").replace(/\bnode\s+"[^"]+"/g, 'node "..."').replace(/\s+/g, " ").trim();
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const msg of messages) {
+      const key = normalize(msg);
+      if (!seen.has(key) && unique.length < maxCount) {
+        seen.add(key);
+        unique.push(msg);
+      }
+    }
+    return unique;
+  }
+  recencyWeight(fileDate, halfLifeDays = 30) {
+    const daysAgo = Math.max(0, (Date.now() - (/* @__PURE__ */ new Date(fileDate + "T12:00:00Z")).getTime()) / (1e3 * 60 * 60 * 24));
+    return Math.max(0.1, Math.exp(-Math.LN2 * daysAgo / halfLifeDays));
+  }
+  async readAllEvents(days) {
+    return readTelemetryEvents(this.telemetryDir, days);
   }
 };
 
@@ -1537,6 +2123,7 @@ var Kairos = class {
   logger;
   telemetry;
   telemetryReader;
+  patternAnalyzer;
   model;
   saveQueue = Promise.resolve(null);
   constructor(options) {
@@ -1562,12 +2149,15 @@ var Kairos = class {
     if (options.telemetry === true) {
       this.telemetry = new TelemetryCollector();
       this.telemetryReader = new TelemetryReader();
+      this.patternAnalyzer = new PatternAnalyzer();
     } else if (typeof options.telemetry === "string") {
       this.telemetry = new TelemetryCollector(options.telemetry);
       this.telemetryReader = new TelemetryReader(options.telemetry);
+      this.patternAnalyzer = new PatternAnalyzer(options.telemetry);
     } else {
       this.telemetry = null;
       this.telemetryReader = null;
+      this.patternAnalyzer = null;
     }
   }
   requireProvider() {
@@ -1605,11 +2195,45 @@ var Kairos = class {
         this.logger.info(`Telemetry: ${highFreq.length} high-frequency failure rule(s) will be warned about`);
       }
     }
-    const designResult = await this.designer.design(
-      { description, ...options?.name ? { name: options.name } : {} },
-      matches,
-      globalFailureRates
-    );
+    let designResult;
+    try {
+      designResult = await this.designer.design(
+        { description, ...options?.name ? { name: options.name } : {} },
+        matches,
+        globalFailureRates
+      );
+    } catch (err) {
+      if (err instanceof ValidationError && err.attemptMetadata) {
+        for (const meta of err.attemptMetadata) {
+          await this.telemetry?.emit("generation_attempt", {
+            description,
+            attempt: meta.attempt,
+            temperature: meta.temperature,
+            durationMs: meta.durationMs,
+            tokensInput: meta.tokensInput,
+            tokensOutput: meta.tokensOutput,
+            validationPassed: meta.validationPassed,
+            issueCount: meta.issues.length,
+            issues: meta.issues.map((i) => ({ rule: i.rule, message: i.message, nodeId: i.nodeId ?? null, nodeType: i.nodeType ?? null }))
+          });
+        }
+        await this.telemetry?.emit("build_complete", {
+          description,
+          success: false,
+          totalAttempts: err.attemptMetadata.length,
+          totalDurationMs: Date.now() - buildStart,
+          totalTokensInput: err.attemptMetadata.reduce((s, m) => s + m.tokensInput, 0),
+          totalTokensOutput: err.attemptMetadata.reduce((s, m) => s + m.tokensOutput, 0),
+          workflowName: null,
+          workflowId: null,
+          dryRun: options?.dryRun ?? false,
+          credentialsNeeded: 0,
+          warnedRules: err.warnedRules ?? []
+        });
+        this.updatePatterns();
+      }
+      throw err;
+    }
     await this.emitAttemptTelemetry(description, designResult);
     const workflow = options?.name ? { ...designResult.workflow, name: options.name } : designResult.workflow;
     this.saveToLibrary(workflow, description, designResult, matches);
@@ -1626,8 +2250,10 @@ var Kairos = class {
         workflowName: workflow.name,
         workflowId: null,
         dryRun: true,
-        credentialsNeeded: designResult.credentialsNeeded.length
+        credentialsNeeded: designResult.credentialsNeeded.length,
+        warnedRules: designResult.warnedRules
       });
+      this.updatePatterns();
       return {
         workflowId: null,
         name: workflow.name,
@@ -1656,8 +2282,10 @@ var Kairos = class {
       workflowName: deployed.name,
       workflowId: deployed.workflowId,
       dryRun: false,
-      credentialsNeeded: designResult.credentialsNeeded.length
+      credentialsNeeded: designResult.credentialsNeeded.length,
+      warnedRules: designResult.warnedRules
     });
+    this.updatePatterns();
     return {
       workflowId: deployed.workflowId,
       name: deployed.name,
@@ -1680,7 +2308,41 @@ var Kairos = class {
     await this.library.initialize();
     const matches = await this.library.search(description);
     const globalFailureRates = await this.telemetryReader?.getFailureRates() ?? [];
-    const designResult = await this.designer.design({ description }, matches, globalFailureRates);
+    let designResult;
+    try {
+      designResult = await this.designer.design({ description }, matches, globalFailureRates);
+    } catch (err) {
+      if (err instanceof ValidationError && err.attemptMetadata) {
+        for (const meta of err.attemptMetadata) {
+          await this.telemetry?.emit("generation_attempt", {
+            description,
+            attempt: meta.attempt,
+            temperature: meta.temperature,
+            durationMs: meta.durationMs,
+            tokensInput: meta.tokensInput,
+            tokensOutput: meta.tokensOutput,
+            validationPassed: meta.validationPassed,
+            issueCount: meta.issues.length,
+            issues: meta.issues.map((i) => ({ rule: i.rule, message: i.message, nodeId: i.nodeId ?? null, nodeType: i.nodeType ?? null }))
+          });
+        }
+        await this.telemetry?.emit("build_complete", {
+          description,
+          success: false,
+          totalAttempts: err.attemptMetadata.length,
+          totalDurationMs: Date.now() - buildStart,
+          totalTokensInput: err.attemptMetadata.reduce((s, m) => s + m.tokensInput, 0),
+          totalTokensOutput: err.attemptMetadata.reduce((s, m) => s + m.tokensOutput, 0),
+          workflowName: null,
+          workflowId: null,
+          dryRun: false,
+          credentialsNeeded: 0,
+          warnedRules: err.warnedRules ?? []
+        });
+        this.updatePatterns();
+      }
+      throw err;
+    }
     await this.emitAttemptTelemetry(description, designResult);
     const provider = this.requireProvider();
     const deployed = await provider.update(id, designResult.workflow);
@@ -1698,8 +2360,10 @@ var Kairos = class {
       workflowName: deployed.name,
       workflowId: deployed.workflowId,
       dryRun: false,
-      credentialsNeeded: designResult.credentialsNeeded.length
+      credentialsNeeded: designResult.credentialsNeeded.length,
+      warnedRules: designResult.warnedRules
     });
+    this.updatePatterns();
     return {
       workflowId: deployed.workflowId,
       name: deployed.name,
@@ -1714,6 +2378,13 @@ var Kairos = class {
     await this.saveQueue.catch(() => {
     });
   }
+  updatePatterns() {
+    if (!this.patternAnalyzer) return;
+    this.saveQueue = this.saveQueue.then(() => this.patternAnalyzer.analyzeAndSave()).then(() => null).catch((err) => {
+      this.logger.warn("Pattern analysis failed (non-fatal)", { err: String(err) });
+      return null;
+    });
+  }
   async emitAttemptTelemetry(description, designResult) {
     for (const meta of designResult.attemptMetadata) {
       await this.telemetry?.emit("generation_attempt", {
@@ -1725,7 +2396,7 @@ var Kairos = class {
         tokensOutput: meta.tokensOutput,
         validationPassed: meta.validationPassed,
         issueCount: meta.issues.length,
-        issues: meta.issues.map((i) => ({ rule: i.rule, message: i.message }))
+        issues: meta.issues.map((i) => ({ rule: i.rule, message: i.message, nodeId: i.nodeId ?? null, nodeType: i.nodeType ?? null }))
       });
     }
   }
@@ -1824,9 +2495,9 @@ var Kairos = class {
 };
 
 // src/library/file-library.ts
-var import_promises3 = require("fs/promises");
-var import_node_path3 = require("path");
-var import_node_os3 = require("os");
+var import_promises4 = require("fs/promises");
+var import_node_path6 = require("path");
+var import_node_os5 = require("os");
 
 // src/library/scorer.ts
 var WEIGHTS = {
@@ -2062,7 +2733,7 @@ var FileLibrary = class {
   initPromise = null;
   writeQueue = Promise.resolve();
   constructor(dir) {
-    this.dir = dir ?? (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".kairos", "library");
+    this.dir = dir ?? (0, import_node_path6.join)((0, import_node_os5.homedir)(), ".kairos", "library");
   }
   async initialize() {
     if (!this.initPromise) {
@@ -2071,10 +2742,10 @@ var FileLibrary = class {
     return this.initPromise;
   }
   async doInitialize() {
-    await (0, import_promises3.mkdir)(this.dir, { recursive: true });
-    const indexPath = (0, import_node_path3.join)(this.dir, "index.json");
+    await (0, import_promises4.mkdir)(this.dir, { recursive: true });
+    const indexPath = (0, import_node_path6.join)(this.dir, "index.json");
     try {
-      const raw = await (0, import_promises3.readFile)(indexPath, "utf-8");
+      const raw = await (0, import_promises4.readFile)(indexPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) {
         this.workflows = [];
@@ -2204,10 +2875,10 @@ var FileLibrary = class {
   }
   persist() {
     this.writeQueue = this.writeQueue.then(async () => {
-      const indexPath = (0, import_node_path3.join)(this.dir, "index.json");
+      const indexPath = (0, import_node_path6.join)(this.dir, "index.json");
       const tmpPath = `${indexPath}.tmp`;
-      await (0, import_promises3.writeFile)(tmpPath, JSON.stringify(this.workflows, null, 2), "utf-8");
-      await (0, import_promises3.rename)(tmpPath, indexPath);
+      await (0, import_promises4.writeFile)(tmpPath, JSON.stringify(this.workflows, null, 2), "utf-8");
+      await (0, import_promises4.rename)(tmpPath, indexPath);
     });
     return this.writeQueue;
   }
@@ -2395,6 +3066,7 @@ Kairos SDK \u2014 LLM-powered n8n workflow generation
 Usage:
   kairos init                         First-time setup wizard
   kairos build <description> [options]
+  kairos patterns [options]
   kairos list
   kairos get <id>
   kairos activate <id>
@@ -2407,6 +3079,10 @@ Build options:
   --name <name>   Override the generated workflow name
   --activate      Activate the workflow after deployment
 
+Patterns options:
+  --days <days>   Analysis window (default: 30)
+  --json          Output raw JSON instead of summary
+
 Sync options:
   --max <count>   Maximum templates to fetch (default: 500)
 
@@ -2604,10 +3280,85 @@ async function handleSyncTemplates(flags) {
   console.error(`  Duplicates: ${result.skippedDuplicate} (already in library)`);
   console.error(`  Paid:       ${result.skippedPaid} (skipped)`);
 }
+async function handlePatterns(flags) {
+  const days = typeof flags["days"] === "string" ? parseInt(flags["days"], 10) : 30;
+  const analyzer = PatternAnalyzer.fromEnv();
+  const analysis = await analyzer.analyzeAndSave(days);
+  if (flags["json"] === true) {
+    console.log(JSON.stringify(analysis, null, 2));
+    return;
+  }
+  console.log(`
+Kairos Pattern Analysis (last ${days} days)`);
+  console.log("\u2500".repeat(45));
+  console.log(`  Builds:          ${analysis.summary.totalBuilds}`);
+  console.log(`  Attempts:        ${analysis.summary.totalAttempts}`);
+  console.log(`  First-try pass:  ${(analysis.summary.firstTryPassRate * 100).toFixed(1)}%`);
+  console.log(`  Correction rate: ${(analysis.summary.correctionRate * 100).toFixed(1)}%`);
+  if (analysis.summary.singleAttemptFailRate !== void 0) {
+    console.log(`  Single-attempt failures: ${(analysis.summary.singleAttemptFailRate * 100).toFixed(1)}%`);
+  }
+  console.log(`  Avg duration:    ${(analysis.summary.avgDurationMs / 1e3).toFixed(1)}s`);
+  const active = analysis.topFailureRules.filter((p) => p.state !== "resolved");
+  const resolved = analysis.topFailureRules.filter((p) => p.state === "resolved");
+  if (active.length > 0) {
+    console.log(`
+Active Failure Patterns:`);
+    for (const p of active) {
+      const regressionTag = p.regressed ? "[REGRESSION] " : "";
+      const stateTag = p.state === "confirmed" ? "[CONFIRMED]" : "[DRAFT]";
+      const trendIcon = p.trend === "improving" ? " ^" : p.trend === "worsening" ? " v" : p.trend === "new" ? " *" : "";
+      const stage = p.pipelineStage.replace(/_/g, " ");
+      const scoreStr = p.compositeScore.toFixed(3);
+      console.log(`  Rule ${p.rule} ${regressionTag}${stateTag}${trendIcon} \u2014 score ${scoreStr} | ${p.failureCount} failures (${(p.confidence * 100).toFixed(1)}%) [${stage}]`);
+      const f = p.scoringFactors;
+      console.log(`    Factors: confidence=${f.rawConfidence} \xD7 impact=${f.impact} \xD7 recency=${f.recency} + boost=${f.stickinessBoost}`);
+      if (p.mitigation) console.log(`    Fix: ${p.mitigation}`);
+      if (p.exampleMessages.length > 0) console.log(`    e.g. ${p.exampleMessages[0]}`);
+    }
+  } else {
+    console.log(`
+No active failure patterns.`);
+  }
+  if (resolved.length > 0) {
+    console.log(`
+Resolved Patterns:`);
+    for (const p of resolved) {
+      console.log(`  Rule ${p.rule} \u2014 previously confirmed, 0 failures in current window`);
+    }
+  }
+  if (analysis.failingCredentialTypes.length > 0) {
+    console.log(`
+Failing Credential Types:`);
+    for (const c of analysis.failingCredentialTypes) {
+      console.log(`  ${c.type}: ${c.count} failures`);
+    }
+  }
+  if (analysis.warningEffectiveness && analysis.warningEffectiveness.length > 0) {
+    console.log(`
+Warning Effectiveness:`);
+    for (const w of analysis.warningEffectiveness) {
+      console.log(`  Rule ${w.rule}: warned ${w.timesWarned}x, prevented ${w.timesWarnedAndPassed}x (${Math.round(w.effectivenessRate * 100)}% effective)`);
+    }
+  }
+  const drift = analysis.drift;
+  if (drift) {
+    console.log(`
+Drift Detection: ${drift.healthy ? "HEALTHY" : "ALERTS FOUND"}`);
+    console.log(`  Coverage: ${drift.coveredRules}/${drift.totalRules} rules have mitigations + stage mappings`);
+    if (drift.alerts.length > 0) {
+      for (const a of drift.alerts) {
+        console.log(`  [${a.type}] Rule ${a.rule}: ${a.message}`);
+      }
+    }
+  }
+  console.log(`
+Patterns saved to ~/.kairos/patterns.json`);
+}
 async function handleInit() {
-  const { writeFile: writeFile2, readFile: readFile3, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join4 } = await import("path");
-  const { homedir: homedir4 } = await import("os");
+  const { writeFile: writeFile3, readFile: readFile2, mkdir: mkdir4 } = await import("fs/promises");
+  const { join: join7 } = await import("path");
+  const { homedir: homedir6 } = await import("os");
   const readline = await import("readline");
   const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
   const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
@@ -2615,10 +3366,10 @@ async function handleInit() {
   console.error("  Kairos SDK \u2014 Setup Wizard");
   console.error("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   console.error("");
-  const envPath = join4(process.cwd(), ".env");
+  const envPath = join7(process.cwd(), ".env");
   let existingEnv = "";
   try {
-    existingEnv = await readFile3(envPath, "utf-8");
+    existingEnv = await readFile2(envPath, "utf-8");
   } catch {
   }
   const has = (key) => existingEnv.includes(key) || !!process.env[key];
@@ -2644,7 +3395,7 @@ async function handleInit() {
   rl.close();
   if (lines.length > 0) {
     const newContent = existingEnv ? existingEnv.trimEnd() + "\n" + lines.join("\n") + "\n" : lines.join("\n") + "\n";
-    await writeFile2(envPath, newContent, "utf-8");
+    await writeFile3(envPath, newContent, "utf-8");
     console.error(`
   Saved to ${envPath}`);
   } else {
@@ -2679,8 +3430,8 @@ async function handleInit() {
     });
     console.error(`  Synced ${result.saved} templates (${result.blocked} blocked, ${result.skippedDuplicate} duplicates)`);
   }
-  const kairosDir = join4(homedir4(), ".kairos");
-  await mkdir3(join4(kairosDir, "telemetry"), { recursive: true });
+  const kairosDir = join7(homedir6(), ".kairos");
+  await mkdir4(join7(kairosDir, "telemetry"), { recursive: true });
   console.error("");
   console.error("  Setup complete! Try:");
   console.error("");
@@ -2700,6 +3451,9 @@ async function main() {
     case "build":
       await handleBuild(positional, flags);
       break;
+    case "patterns":
+      await handlePatterns(flags);
+      break;
     case "list":
       await handleList();
       break;