@kairos-sdk/core 0.3.2 → 0.4.5

package/dist/mcp-server.cjs

@@ -253,14 +253,28 @@ function buildSearchCorpus(w) {
   return `${w.description} ${w.workflow.name} ${w.tags.join(" ")} ${nodeTokens.join(" ")}`;
 }
 var MAX_LIBRARY_SIZE = 500;
+function isValidMeta(item) {
+  return typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.description === "string" && typeof item.workflowName === "string" && Array.isArray(item.cachedNodeTypes);
+}
+function isValidOldEntry(item) {
+  return typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.description === "string" && typeof item.workflow === "object" && item.workflow !== null && Array.isArray(
+    item.workflow.nodes
+  );
+}
 var FileLibrary = class {
   dir;
-  workflows = [];
+  meta = [];
   initPromise = null;
   writeQueue = Promise.resolve();
   constructor(dir) {
     this.dir = dir ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".kairos", "library");
   }
+  get workflowsDir() {
+    return (0, import_node_path.join)(this.dir, "workflows");
+  }
+  workflowFilePath(id) {
+    return (0, import_node_path.join)(this.workflowsDir, `${id}.json`);
+  }
   async initialize() {
     if (!this.initPromise) {
       this.initPromise = this.doInitialize();
@@ -270,60 +284,147 @@ var FileLibrary = class {
   async doInitialize() {
     await (0, import_promises.mkdir)(this.dir, { recursive: true });
     const indexPath = (0, import_node_path.join)(this.dir, "index.json");
+    let workflowsDirExists = false;
     try {
-      const raw = await (0, import_promises.readFile)(indexPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (!Array.isArray(parsed)) {
-        this.workflows = [];
-      } else {
-        this.workflows = parsed.filter(
-          (item) => typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.description === "string" && typeof item.workflow === "object" && item.workflow !== null && Array.isArray(item.workflow.nodes)
-        );
+      await (0, import_promises.stat)(this.workflowsDir);
+      workflowsDirExists = true;
+    } catch {
+    }
+    if (workflowsDirExists) {
+      try {
+        const raw = await (0, import_promises.readFile)(indexPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+          this.meta = parsed.filter(isValidMeta);
+        }
+      } catch {
+        this.meta = [];
       }
+    } else {
+      try {
+        const raw = await (0, import_promises.readFile)(indexPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed) && parsed.length > 0 && isValidOldEntry(parsed[0])) {
+          await this.migrateFromMonolithic(parsed.filter(isValidOldEntry));
+          return;
+        }
+      } catch {
+      }
+      this.meta = [];
+      await (0, import_promises.mkdir)(this.workflowsDir, { recursive: true });
+    }
+  }
+  /**
+   * One-time transparent migration from v0.4.x monolithic index.json.
+   * Splits each stored workflow into a per-file workflow JSON and a lightweight
+   * meta entry. Rewrites index.json in the new format.
+   */
+  async migrateFromMonolithic(oldEntries) {
+    await (0, import_promises.mkdir)(this.workflowsDir, { recursive: true });
+    const newMeta = [];
+    for (const entry of oldEntries) {
+      const wfPath = this.workflowFilePath(entry.id);
+      const tmpPath = `${wfPath}.tmp`;
+      await (0, import_promises.writeFile)(tmpPath, JSON.stringify(entry.workflow), "utf-8");
+      await (0, import_promises.rename)(tmpPath, wfPath);
+      const { workflow, ...metaFields } = entry;
+      newMeta.push({
+        ...metaFields,
+        workflowName: workflow.name,
+        cachedNodeTypes: workflow.nodes.map((n) => n.type)
+      });
+    }
+    this.meta = newMeta;
+    await this.persistNow();
+  }
+  async loadWorkflowFile(id) {
+    try {
+      const raw = await (0, import_promises.readFile)(this.workflowFilePath(id), "utf-8");
+      return JSON.parse(raw);
     } catch {
-      this.workflows = [];
+      return null;
     }
   }
+  async writeWorkflowFile(id, workflow) {
+    const wfPath = this.workflowFilePath(id);
+    const tmpPath = `${wfPath}.tmp`;
+    await (0, import_promises.writeFile)(tmpPath, JSON.stringify(workflow), "utf-8");
+    await (0, import_promises.rename)(tmpPath, wfPath);
+  }
+  /**
+   * Build a lightweight StoredWorkflow shell from a meta entry for use in
+   * scoring / clustering. Only node.type is populated in each node — no other
+   * node fields are used by hybridScore or clusterWorkflows.
+   */
+  makeSearchShell(m) {
+    return {
+      ...m,
+      workflow: {
+        name: m.workflowName,
+        nodes: m.cachedNodeTypes.map((type) => ({
+          id: "",
+          name: "",
+          type,
+          typeVersion: 1,
+          position: [0, 0],
+          parameters: {}
+        })),
+        connections: {}
+      }
+    };
+  }
   async search(description, options) {
-    const searchable = this.workflows.filter((w) => w.trustLevel !== "blocked");
-    if (searchable.length === 0) return [];
+    const filteredMeta = this.meta.filter((m) => m.trustLevel !== "blocked");
+    if (filteredMeta.length === 0) return [];
     const limit = options?.limit ?? 3;
     const queryTokens = tokenize(description);
     if (queryTokens.length === 0) return [];
-    const docTokenArrays = searchable.map((w) => tokenize(buildSearchCorpus(w)));
+    const shells = filteredMeta.map((m) => this.makeSearchShell(m));
+    const docTokenArrays = shells.map((w) => tokenize(buildSearchCorpus(w)));
     const docTokenSets = docTokenArrays.map((tokens) => new Set(tokens));
-    const docCount = searchable.length;
+    const docCount = shells.length;
     const idf = /* @__PURE__ */ new Map();
     const allTokens = new Set(queryTokens);
     for (const token of allTokens) {
       const docsWithToken = docTokenSets.filter((d) => d.has(token)).length;
       idf.set(token, Math.log((docCount + 1) / (docsWithToken + 1)) + 1);
     }
-    const scored = hybridScore(queryTokens, description, searchable, docTokenArrays, idf).filter((m) => m.score > 0).sort((a, b) => b.score - a.score);
-    const clusters = clusterWorkflows(searchable);
+    const scored = hybridScore(queryTokens, description, shells, docTokenArrays, idf).filter((m) => m.score > 0).sort((a, b) => b.score - a.score);
+    const clusters = clusterWorkflows(shells);
     const reranked = rerank(scored, clusters).slice(0, limit);
-    const results = reranked.map((m) => {
-      return { workflow: m.workflow, score: m.score, mode: scoreToMode(m.score) };
-    });
-    if (results.length > 0) {
-      for (const r of results) {
-        r.workflow.timesRetrieved = (r.workflow.timesRetrieved ?? 0) + 1;
-      }
-      this.persist();
-    }
-    return results;
+    if (reranked.length === 0) return [];
+    for (const r of reranked) {
+      const m = this.meta.find((m2) => m2.id === r.workflow.id);
+      if (m) m.timesRetrieved = (m.timesRetrieved ?? 0) + 1;
+    }
+    this.persist();
+    const results = await Promise.all(
+      reranked.map(async (r) => {
+        const m = this.meta.find((meta) => meta.id === r.workflow.id);
+        const workflow = await this.loadWorkflowFile(r.workflow.id);
+        if (!workflow) return null;
+        return {
+          workflow: { ...m, workflow },
+          score: r.score,
+          mode: scoreToMode(r.score)
+        };
+      })
+    );
+    return results.filter((r) => r !== null);
   }
   async save(workflow, metadata) {
     const id = generateUUID();
+    await this.writeWorkflowFile(id, workflow);
     const failurePatterns = this.deduplicateFailurePatterns(metadata.failurePatterns);
-    const stored = {
+    const meta = {
       id,
-      workflow,
       description: metadata.description,
       tags: metadata.tags ?? [],
       platform: metadata.platform ?? "n8n",
       deployCount: 0,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workflowName: workflow.name,
+      cachedNodeTypes: workflow.nodes.map((n) => n.type),
       ...failurePatterns?.length ? { failurePatterns } : {},
       ...metadata.sourceWorkflowIds?.length ? { sourceWorkflowIds: metadata.sourceWorkflowIds } : {},
       ...metadata.generationMode ? { generationMode: metadata.generationMode } : {},
@@ -335,31 +436,35 @@ var FileLibrary = class {
       ...metadata.sourceUrl ? { sourceUrl: metadata.sourceUrl } : {},
       ...metadata.trustLevel ? { trustLevel: metadata.trustLevel } : {}
     };
-    this.workflows.push(stored);
-    if (this.workflows.length > MAX_LIBRARY_SIZE) {
-      this.workflows.sort((a, b) => (b.deployCount ?? 1) - (a.deployCount ?? 1));
-      this.workflows = this.workflows.slice(0, MAX_LIBRARY_SIZE);
+    this.meta.push(meta);
+    if (this.meta.length > MAX_LIBRARY_SIZE) {
+      this.meta.sort((a, b) => {
+        if (a.id === id) return -1;
+        if (b.id === id) return 1;
+        return (b.deployCount ?? 0) - (a.deployCount ?? 0);
+      });
+      this.meta = this.meta.slice(0, MAX_LIBRARY_SIZE);
     }
     await this.persist();
     return id;
   }
   async recordDeployment(id) {
-    const w = this.workflows.find((w2) => w2.id === id);
-    if (w) {
-      w.deployCount++;
-      w.lastDeployedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const m = this.meta.find((m2) => m2.id === id);
+    if (m) {
+      m.deployCount++;
+      m.lastDeployedAt = (/* @__PURE__ */ new Date()).toISOString();
       await this.persist();
     }
   }
   async recordOutcome(id, outcome) {
-    const w = this.workflows.find((w2) => w2.id === id);
-    if (!w) return;
+    const m = this.meta.find((m2) => m2.id === id);
+    if (!m) return;
     if (outcome.mode === "direct") {
-      w.timesUsedAsDirect = (w.timesUsedAsDirect ?? 0) + 1;
+      m.timesUsedAsDirect = (m.timesUsedAsDirect ?? 0) + 1;
     } else {
-      w.timesUsedAsReference = (w.timesUsedAsReference ?? 0) + 1;
+      m.timesUsedAsReference = (m.timesUsedAsReference ?? 0) + 1;
     }
-    const stats = w.outcomeStats ?? { totalUses: 0, totalAttempts: 0, firstTryPasses: 0, failedRules: {} };
+    const stats = m.outcomeStats ?? { totalUses: 0, totalAttempts: 0, firstTryPasses: 0, failedRules: {} };
     stats.totalUses++;
     stats.totalAttempts += outcome.attempts;
     if (outcome.firstTryPass) stats.firstTryPasses++;
@@ -367,24 +472,35 @@ var FileLibrary = class {
       const key = String(rule);
       stats.failedRules[key] = (stats.failedRules[key] ?? 0) + 1;
     }
-    w.outcomeStats = stats;
+    m.outcomeStats = stats;
     await this.persist();
   }
   async drain() {
     await this.writeQueue;
   }
   async get(id) {
-    return this.workflows.find((w) => w.id === id) ?? null;
+    const m = this.meta.find((m2) => m2.id === id);
+    if (!m) return null;
+    const workflow = await this.loadWorkflowFile(id);
+    if (!workflow) return null;
+    return { ...m, workflow };
   }
   async list(filters) {
-    let result = this.workflows;
+    let filtered = this.meta;
     if (filters?.platform) {
-      result = result.filter((w) => w.platform === filters.platform);
+      filtered = filtered.filter((m) => m.platform === filters.platform);
     }
     if (filters?.tags && filters.tags.length > 0) {
-      result = result.filter((w) => filters.tags.some((t) => w.tags.includes(t)));
-    }
-    return result;
+      filtered = filtered.filter((m) => filters.tags.some((t) => m.tags.includes(t)));
+    }
+    const results = await Promise.all(
+      filtered.map(async (m) => {
+        const workflow = await this.loadWorkflowFile(m.id);
+        if (!workflow) return null;
+        return { ...m, workflow };
+      })
+    );
+    return results.filter((r) => r !== null);
   }
   deduplicateFailurePatterns(patterns) {
     if (!patterns?.length) return void 0;
@@ -399,11 +515,36 @@ var FileLibrary = class {
     }
     return [...map.values()];
   }
+  /**
+   * Direct write used only during migration (before writeQueue is needed).
+   */
+  async persistNow() {
+    const indexPath = (0, import_node_path.join)(this.dir, "index.json");
+    const tmpPath = `${indexPath}.tmp`;
+    await (0, import_promises.writeFile)(tmpPath, JSON.stringify(this.meta, null, 2), "utf-8");
+    await (0, import_promises.rename)(tmpPath, indexPath);
+  }
   persist() {
     this.writeQueue = this.writeQueue.then(async () => {
       const indexPath = (0, import_node_path.join)(this.dir, "index.json");
+      let onDisk = [];
+      try {
+        const raw = await (0, import_promises.readFile)(indexPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+          onDisk = parsed.filter(isValidMeta);
+        }
+      } catch {
+      }
+      const ourIds = new Set(this.meta.map((m) => m.id));
+      const external = onDisk.filter((m) => !ourIds.has(m.id));
+      let merged = [...this.meta, ...external];
+      if (merged.length > MAX_LIBRARY_SIZE) {
+        merged.sort((a, b) => (b.deployCount ?? 0) - (a.deployCount ?? 0));
+        merged = merged.slice(0, MAX_LIBRARY_SIZE);
+      }
       const tmpPath = `${indexPath}.tmp`;
-      await (0, import_promises.writeFile)(tmpPath, JSON.stringify(this.workflows, null, 2), "utf-8");
+      await (0, import_promises.writeFile)(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
       await (0, import_promises.rename)(tmpPath, indexPath);
     });
     return this.writeQueue;
@@ -577,17 +718,31 @@ var N8nValidator = class {
     this.checkRule21(workflow, issues);
     this.checkRule22(workflow, issues);
     this.checkRule23(workflow, issues);
+    this.checkRule24(workflow, issues);
+    this.checkRule25(workflow, issues);
+    this.checkRule26(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) {
@@ -698,10 +853,14 @@ var N8nValidator = class {
   checkRule11(w, issues) {
     if (!Array.isArray(w.nodes) || typeof w.connections !== "object" || w.connections === null) return;
     const reachable = /* @__PURE__ */ new Set();
-    for (const [, outputs] of Object.entries(w.connections)) {
+    const aiSubNodeSources = /* @__PURE__ */ new Set();
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
       if (typeof outputs !== "object" || outputs === null) continue;
-      for (const portGroup of Object.values(outputs)) {
+      let hasAiPort = false;
+      for (const [portName, portGroup] of Object.entries(outputs)) {
         if (!Array.isArray(portGroup)) continue;
+        const isAiPort = portName.startsWith("ai_");
+        if (isAiPort) hasAiPort = true;
         for (const targets of portGroup) {
           if (!Array.isArray(targets)) continue;
           for (const target of targets) {
@@ -710,10 +869,13 @@ var N8nValidator = class {
           }
         }
       }
+      if (hasAiPort) aiSubNodeSources.add(sourceName);
     }
     for (const node of w.nodes) {
       if (node.type.includes("stickyNote")) continue;
-      if (!this.isTriggerNode(node) && !reachable.has(node.name)) {
+      if (this.isTriggerNode(node)) continue;
+      if (aiSubNodeSources.has(node.name)) continue;
+      if (!reachable.has(node.name)) {
         this.warn(issues, 11, `Node "${node.name}" has no incoming connections and may never execute`, node.id);
       }
     }
@@ -909,6 +1071,76 @@ var N8nValidator = class {
       }
     }
   }
+  // Rule 24 (WARN): deprecated accessor syntax in expressions
+  checkRule24(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const deprecated = /\$node\s*\[/;
+    for (const node of w.nodes) {
+      for (const expr of this.extractExpressions(node.parameters)) {
+        if (deprecated.test(expr)) {
+          this.warn(
+            issues,
+            24,
+            `Node "${node.name}" uses deprecated accessor $node["..."] \u2014 use $('NodeName').item.json.field instead`,
+            node.id
+          );
+          break;
+        }
+      }
+    }
+  }
+  // Rule 25 (WARN): wrong item index assumptions in expressions
+  checkRule25(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const itemIndex = /\$json\s*\.\s*items\s*\[/;
+    for (const node of w.nodes) {
+      for (const expr of this.extractExpressions(node.parameters)) {
+        if (itemIndex.test(expr)) {
+          this.warn(
+            issues,
+            25,
+            `Node "${node.name}" accesses $json.items[n] \u2014 n8n flattens items automatically, use $json.field directly`,
+            node.id
+          );
+          break;
+        }
+      }
+    }
+  }
+  // Rule 26 (WARN): missing .first() or .all() on node references
+  checkRule26(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const bareRef = /\$\(\s*'[^']+'\s*\)\s*\.json/;
+    for (const node of w.nodes) {
+      for (const expr of this.extractExpressions(node.parameters)) {
+        if (bareRef.test(expr)) {
+          this.warn(
+            issues,
+            26,
+            `Node "${node.name}" references $('NodeName').json without .first() or .all() \u2014 use $('NodeName').first().json.field`,
+            node.id
+          );
+          break;
+        }
+      }
+    }
+  }
+  extractExpressions(params) {
+    const expressions = [];
+    const walk = (val) => {
+      if (typeof val === "string") {
+        if (val.includes("={{") || val.includes("$node") || val.includes("$('")) {
+          expressions.push(val);
+        }
+      } else if (Array.isArray(val)) {
+        for (const item of val) walk(item);
+      } else if (val !== null && typeof val === "object") {
+        for (const v of Object.values(val)) walk(v);
+      }
+    };
+    walk(params);
+    return expressions;
+  }
   // Rule 21 (WARN): webhook with responseMode="responseNode" must have respondToWebhook node
   checkRule21(w, issues) {
     if (!Array.isArray(w.nodes)) return;
@@ -1164,6 +1396,11 @@ var N8nApiClient = class {
   }
 };
 
+// src/generation/prompt-builder.ts
+var import_node_fs = require("fs");
+var import_node_path2 = require("path");
+var import_node_os2 = 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.
 
@@ -1193,9 +1430,11 @@ id, active, createdAt, updatedAt, versionId, meta, isArchived, activeVersionId,
 - Never reuse IDs, never use sequential fake IDs like "node-1"
 
 ### Credentials:
-- Only reference credentials with exact type names (see catalog below)
-- If credential ID is unknown, OMIT the credentials block entirely \u2014 never invent credential IDs
-- Never put API keys or tokens in parameters when a credential type exists
+- Each credential is keyed by its type string, with an object value containing id and name:
+  "credentials": { "slackOAuth2Api": { "id": "placeholder-id", "name": "My Slack Credential" } }
+- Use "placeholder-id" as the id \u2014 users replace this with their real credential ID from n8n after deployment
+- The credentialsNeeded field in your response declares what credentials the user must configure
+- Never put API keys or tokens directly in node parameters when a credential type exists
 
 ### Node names:
 - All node names must be unique within the workflow
@@ -1242,6 +1481,23 @@ Node parameters like conditions, assignments, and rule intervals MUST include al
 
 ---
 
+## EXPRESSION SYNTAX \u2014 how to reference upstream node data
+
+### Accessing a field from an upstream node:
+- CORRECT:   $('NodeName').item.json.field
+- WRONG:     $node["NodeName"].json.field   \u2190 deprecated accessor, fails at runtime (Rule 24)
+
+### Accessing array items from $json:
+- CORRECT:   $json.field                    \u2190 n8n auto-flattens items; each item is already a flat object
+- WRONG:     $json.items[0].field           \u2190 do not index into items[] (Rule 25)
+
+### Calling node data \u2014 always qualify with .first() or .all():
+- CORRECT:   $('NodeName').first().json.field   \u2190 single item
+- CORRECT:   $('NodeName').all()                \u2190 array of all items
+- WRONG:     $('NodeName').json                 \u2190 throws at runtime without .first() or .all() (Rule 26)
+
+---
+
 ## NODE CATALOG \u2014 exact type strings and safe typeVersions
 
 ### Triggers (always at least one required):
@@ -1341,14 +1597,64 @@ Cron: { "rule": { "interval": [{ "field": "cronExpression", "expression": "0 9 *
 5. At least one trigger node present
 6. Every AI Agent has an ai_languageModel sub-node
 7. settings block is complete with executionOrder: "v1"
+8. No deprecated $node["NodeName"].json \u2014 use $('NodeName').item.json.field
+9. No $json.items[0] array indexing \u2014 access fields directly as $json.field
+10. No bare $('NodeName').json \u2014 always use .first().json.field or .all()
 
 ---
 
 Respond ONLY with a generate_workflow tool call. No prose. No markdown outside the tool call.
 If the request is impossible or unclear, set the error field instead of generating a workflow.`;
 
-// src/generation/prompt-builder.ts
-var RULE_REMEDIES = {
+// src/validation/rule-metadata.ts
+var VALIDATOR_RULE_IDS = Array.from({ length: 26 }, (_, 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",
+  24: "expression_syntax",
+  25: "expression_syntax",
+  26: "expression_syntax"
+};
+var RULE_EXAMPLES = {
+  17: {
+    bad: '"credentials": { "slackOAuth2Api": "my-token" }',
+    good: '"credentials": { "slackOAuth2Api": { "id": "placeholder-id", "name": "My Slack OAuth" } }'
+  },
+  24: {
+    bad: '$node["Fetch Data"].json.email',
+    good: "$('Fetch Data').item.json.email"
+  },
+  25: {
+    bad: "$json.items[0].email",
+    good: "$json.email"
+  },
+  26: {
+    bad: "$('Fetch Data').json.email",
+    good: "$('Fetch Data').first().json.email"
+  }
+};
+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",
@@ -1359,18 +1665,51 @@ 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" }',
+  17: 'Each credential entry must be keyed by credential type with an object value: { "slackOAuth2Api": { "id": "placeholder-id", "name": "My Credential" } } \u2014 the key is the credential type, the value has id and name strings',
   18: "AI sub-nodes (languageModel, memory, tool) must be the CONNECTION SOURCE pointing TO the agent \u2014 not the reverse",
   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",
+  24: 'Use modern accessor syntax: $("NodeName").item.json.field instead of deprecated $node["NodeName"].json.field',
+  25: "Access item fields directly with $json.field \u2014 n8n flattens items automatically, do not use $json.items[0]",
+  26: 'Use $("NodeName").first().json.field or $("NodeName").all() \u2014 bare $("NodeName").json without .first() or .all() throws at runtime'
 };
+
+// src/generation/prompt-builder.ts
+var CRITICAL_SCORE_THRESHOLD = 0.15;
+function resolveProfile() {
+  const env = process.env["KAIROS_PROMPT_PROFILE"];
+  if (env === "minimal" || env === "standard" || env === "rich") return env;
+  return "standard";
+}
+var PROACTIVE_EXPRESSION_GUIDANCE = `## Expression Syntax Quick Reference
+
+Always use these patterns in expressions:
+- Access node data:  $('NodeName').item.json.field  (not $node["NodeName"].json)
+- Access JSON field: $json.field  (not $json.items[0].field)
+- Single item:       $('NodeName').first().json.field
+- All items:         $('NodeName').all()`;
 var PromptBuilder = class {
+  patternsPath;
+  profile;
+  _lastActivePatterns = null;
+  constructor(patternsPath, profile) {
+    this.patternsPath = patternsPath ?? (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".kairos", "patterns.json");
+    this.profile = profile ?? resolveProfile();
+  }
+  resolveMaxPatterns() {
+    if (this.profile === "minimal") return 3;
+    if (this.profile === "rich") return 15;
+    return 10;
+  }
   build(request, matches, globalFailureRates = [], dynamicCatalog) {
     const mode = this.resolveMode(matches);
     const system = this.buildSystem(matches, mode, globalFailureRates, dynamicCatalog);
@@ -1407,69 +1746,178 @@ Fix ALL of the above issues in your new response. Do not repeat any of these mis
         cache_control: { type: "ephemeral" }
       }
     ];
-    if (mode === "reference" && matches.length > 0) {
-      const refText = matches.slice(0, 3).map((m) => {
-        const nodes = m.workflow.workflow.nodes.map((n) => `  - ${n.name} (${n.type} v${n.typeVersion})`).join("\n");
-        return `Reference workflow: "${m.workflow.description}" (similarity: ${m.score.toFixed(2)})
+    if (this.profile !== "minimal") {
+      if (mode === "reference" && matches.length > 0) {
+        const refText = matches.slice(0, 3).map((m) => {
+          const nodes = m.workflow.workflow.nodes.map((n) => `  - ${n.name} (${n.type} v${n.typeVersion})`).join("\n");
+          return `Reference workflow: "${m.workflow.description}" (similarity: ${m.score.toFixed(2)})
 Nodes:
 ${nodes}`;
-      }).join("\n\n");
-      blocks.push({
-        type: "text",
-        text: `## Similar Workflows From Library (for reference only \u2014 adapt, do not copy verbatim)
-
-${refText}`
-      });
-    }
-    if (mode === "direct" && matches[0]) {
-      const match = matches[0];
-      const json = JSON.stringify(match.workflow.workflow, null, 2);
-      if (json.length > 3e4) {
-        const nodes = match.workflow.workflow.nodes.map((n) => `  - ${n.name} (${n.type} v${n.typeVersion})`).join("\n");
+        }).join("\n\n");
         blocks.push({
           type: "text",
-          text: `## Closely Matched Workflow (score: ${match.score.toFixed(2)}) \u2014 too large for full JSON, using reference:
+          text: `## Similar Workflows From Library (for reference only \u2014 adapt, do not copy verbatim)
+
+${refText}`
+        });
+      }
+      if (mode === "direct" && matches[0]) {
+        const match = matches[0];
+        const json = JSON.stringify(match.workflow.workflow, null, 2);
+        if (json.length > 3e4) {
+          const nodes = match.workflow.workflow.nodes.map((n) => `  - ${n.name} (${n.type} v${n.typeVersion})`).join("\n");
+          blocks.push({
+            type: "text",
+            text: `## Closely Matched Workflow (score: ${match.score.toFixed(2)}) \u2014 too large for full JSON, using reference:
 Nodes:
 ${nodes}`
-        });
-      } else {
-        blocks.push({
-          type: "text",
-          text: `## Closely Matched Workflow (score: ${match.score.toFixed(2)}) \u2014 adapt this structure:
+          });
+        } else {
+          blocks.push({
+            type: "text",
+            text: `## Closely Matched Workflow (score: ${match.score.toFixed(2)}) \u2014 adapt this structure:
 
 ${json}`
-        });
+          });
+        }
       }
-    }
-    if (mode === "scratch" && matches.length > 0 && matches[0].score >= 0.4) {
-      const hint = matches[0];
-      const nodeTypes = hint.workflow.workflow.nodes.map((n) => n.type.split(".").pop()).join(", ");
-      blocks.push({
-        type: "text",
-        text: `## Weak Structural Hint
+      if (mode === "scratch" && matches.length > 0 && matches[0].score >= 0.4) {
+        const hint = matches[0];
+        const nodeTypes = hint.workflow.workflow.nodes.map((n) => n.type.split(".").pop()).join(", ");
+        blocks.push({
+          type: "text",
+          text: `## Weak Structural Hint
 A loosely similar workflow (score: ${hint.score.toFixed(2)}) used these node types: ${nodeTypes}`
-      });
+        });
+      }
     }
     const warnings = this.buildFailureWarnings(matches, globalFailureRates);
     if (warnings) {
       blocks.push({ type: "text", text: warnings });
     }
+    if (this.profile === "rich") {
+      const expressionRules = /* @__PURE__ */ new Set([24, 25, 26]);
+      const expressionAlreadyCovered = (this._lastActivePatterns ?? []).some((p) => expressionRules.has(p.rule));
+      if (!expressionAlreadyCovered) {
+        blocks.push({ type: "text", text: PROACTIVE_EXPRESSION_GUIDANCE });
+      }
+    }
     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() {
+    const patterns = this._lastActivePatterns ?? this.getActivePatterns(this.resolveMaxPatterns());
+    return patterns.map((p) => p.rule);
+  }
+  getActivePatterns(maxCount = 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, maxCount);
+  }
   buildFailureWarnings(matches, globalFailureRates) {
+    const richPatterns = this.getActivePatterns(this.resolveMaxPatterns());
+    this._lastActivePatterns = richPatterns;
+    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",
+      expression_syntax: "EXPRESSION SYNTAX"
+    };
+    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}` : "";
+          const ex = RULE_EXAMPLES[p.rule];
+          const exampleStr = ex ? `
+  Bad:  ${ex.bad}
+  Good: ${ex.good}` : "";
+          lines.push(`- ${urgency}${statePrefix}Rule ${p.rule}${trendSuffix}: ${p.exampleMessages[0] ?? "No example"}${remedyStr}${exampleStr}`);
+        } 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)`);
     }
@@ -1488,15 +1936,55 @@ Workflow name: "${request.name}"` : "";
 };
 
 // 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();
@@ -1505,9 +1993,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;
@@ -1545,32 +2034,487 @@ 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;
+  _cachedEvents = null;
+  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) => {
+        const sf = p.scoringFactors ?? { rawConfidence: 0, impact: 0, recency: 0, stickinessBoost: 0 };
+        return {
+          ...p,
+          scoringFactors: {
+            ...sf,
+            stickinessBoost: sf.stickinessBoost ?? sf["validationBoost"] ?? 0
+          }
+        };
+      });
+    }
+    return migrated;
+  }
+  async analyze(days = 30) {
+    const previousPatterns = await this.loadPreviousPatterns();
+    const events = await this.readAllEvents(days);
+    this._cachedEvents = events;
+    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 buildId = a.runId ?? a.sessionId;
+      const data = a.data;
+      for (const issue of data.issues ?? []) {
+        if (issue.severity === "warn") continue;
+        const entry = ruleFailures.get(issue.rule) ?? { count: 0, sessions: /* @__PURE__ */ new Set(), recencyWeights: [], allMessages: [], workflowTypes: /* @__PURE__ */ new Map() };
+        entry.count++;
+        entry.sessions.add(buildId);
+        entry.recencyWeights.push(weight);
+        entry.allMessages.push(issue.message);
+        if (data.workflowType) {
+          entry.workflowTypes.set(data.workflowType, (entry.workflowTypes.get(data.workflowType) ?? 0) + 1);
+        }
+        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 buildId = a.runId ?? a.sessionId;
+      const list = sessions.get(buildId) ?? [];
+      list.push(a);
+      sessions.set(buildId, 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);
+      const pattern = {
+        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
+      };
+      if (entry.workflowTypes.size > 0) {
+        pattern.workflowTypeBreakdown = Object.fromEntries(entry.workflowTypes);
+      }
+      return pattern;
+    }).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.runId ?? 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");
+    const sessions = await this.buildSessionSummaries(days);
+    const sessionHistoryPath = (0, import_node_path5.join)(this.outputDir, "session-history.json");
+    const sessionHistoryTmp = `${sessionHistoryPath}.tmp`;
+    await (0, import_promises3.writeFile)(sessionHistoryTmp, JSON.stringify(sessions, null, 2), "utf-8");
+    await (0, import_promises3.rename)(sessionHistoryTmp, sessionHistoryPath);
+    return analysis;
+  }
+  async getSessions(limit = 20) {
+    try {
+      const raw = await (0, import_promises3.readFile)((0, import_node_path5.join)(this.outputDir, "session-history.json"), "utf-8");
+      const all = JSON.parse(raw);
+      return all.slice(-limit);
+    } catch {
+      return [];
+    }
+  }
+  async buildSessionSummaries(days = 30) {
+    const events = this._cachedEvents ?? await this.readAllEvents(days);
+    const buildCompletes = events.filter((e) => e.eventType === "build_complete");
+    const attemptsByBuild = /* @__PURE__ */ new Map();
+    for (const e of events.filter((e2) => e2.eventType === "generation_attempt")) {
+      const buildId = e.runId ?? e.sessionId;
+      const list = attemptsByBuild.get(buildId) ?? [];
+      list.push(e);
+      attemptsByBuild.set(buildId, list);
+    }
+    const summaries = buildCompletes.map((bc) => {
+      const data = bc.data;
+      const sessionAttempts = attemptsByBuild.get(bc.runId ?? bc.sessionId) ?? [];
+      const failedRules = Array.from(new Set(
+        sessionAttempts.flatMap((a) => {
+          const ad = a.data;
+          if (ad.validationPassed !== false) return [];
+          return (ad.issues ?? []).map((i) => i.rule);
+        })
+      ));
+      return {
+        sessionId: bc.sessionId,
+        date: bc.fileDate,
+        description: data.description ?? "",
+        workflowType: data.workflowType ?? null,
+        attempts: data.totalAttempts ?? 1,
+        success: data.success ?? false,
+        failedRules,
+        workflowName: data.workflowName ?? null
+      };
+    });
+    return summaries.sort((a, b) => a.date.localeCompare(b.date));
+  }
+  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-26)`
+        });
+      }
+    }
+    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);
   }
 };
 
@@ -1631,6 +2575,43 @@ ${regularLines}`;
   }
 };
 
+// src/telemetry/collector.ts
+var import_promises4 = require("fs/promises");
+var import_node_path6 = require("path");
+var import_node_os5 = require("os");
+
+// src/telemetry/types.ts
+var TELEMETRY_SCHEMA_VERSION = 2;
+
+// src/telemetry/collector.ts
+var TelemetryCollector = class {
+  dir;
+  sessionId;
+  dirReady = null;
+  constructor(dir) {
+    this.dir = dir ?? (0, import_node_path6.join)((0, import_node_os5.homedir)(), ".kairos", "telemetry");
+    this.sessionId = generateUUID();
+  }
+  async emit(eventType, data, runId) {
+    const event = {
+      schemaVersion: TELEMETRY_SCHEMA_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: this.sessionId,
+      ...runId ? { runId } : {},
+      eventType,
+      data
+    };
+    if (!this.dirReady) {
+      this.dirReady = (0, import_promises4.mkdir)(this.dir, { recursive: true }).then(() => {
+      });
+    }
+    await this.dirReady;
+    const filename = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ".jsonl";
+    const filepath = (0, import_node_path6.join)(this.dir, filename);
+    await (0, import_promises4.appendFile)(filepath, JSON.stringify(event) + "\n", "utf-8");
+  }
+};
+
 // src/utils/logger.ts
 var nullLogger = {
   debug() {
@@ -1643,19 +2624,91 @@ var nullLogger = {
   }
 };
 
+// src/utils/workflow-type.ts
+var TYPE_KEYWORDS = [
+  ["gmail", "email"],
+  ["imap", "email"],
+  ["smtp", "email"],
+  [" email", "email"],
+  ["slack", "slack"],
+  ["telegram", "messaging"],
+  ["discord", "messaging"],
+  [" sms", "messaging"],
+  ["twilio", "messaging"],
+  ["webhook", "webhook"],
+  ["google sheets", "data"],
+  ["spreadsheet", "data"],
+  ["airtable", "data"],
+  ["notion", "data"],
+  ["github", "devops"],
+  ["gitlab", "devops"],
+  ["schedule", "schedule"],
+  [" cron", "schedule"],
+  ["daily", "schedule"],
+  ["weekly", "schedule"],
+  ["hourly", "schedule"],
+  ["every day", "schedule"],
+  ["every hour", "schedule"],
+  ["every morning", "schedule"],
+  ["postgres", "database"],
+  ["mysql", "database"],
+  ["supabase", "database"],
+  ["redis", "database"],
+  [" database", "database"],
+  [" llm", "ai"],
+  [" gpt", "ai"],
+  ["claude", "ai"],
+  [" agent", "ai"],
+  ["langchain", "ai"],
+  [" ai ", "ai"],
+  [" ai", "ai"],
+  ["http request", "api"],
+  ["rest api", "api"],
+  [" api", "api"]
+];
+function inferWorkflowType(description) {
+  const lower = " " + description.toLowerCase();
+  for (const [keyword, type] of TYPE_KEYWORDS) {
+    if (lower.includes(keyword)) return type;
+  }
+  return null;
+}
+
 // src/mcp-server.ts
-var import_node_fs = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path7 = require("path");
+var import_node_os6 = require("os");
 var import_node_url = require("url");
 var import_meta = {};
-var __dirname = (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-var pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path3.join)(__dirname, "..", "package.json"), "utf-8"));
+var __dirname = (0, import_node_path7.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+var pkg = JSON.parse((0, import_node_fs3.readFileSync)((0, import_node_path7.join)(__dirname, "..", "package.json"), "utf-8"));
 var library = new FileLibrary();
 var validator = new N8nValidator();
 var nodeSyncer = new NodeSyncer();
 var lastSync = null;
 var stripper = new N8nFieldStripper();
-var promptBuilder = new PromptBuilder();
+var promptBuilder = new PromptBuilder(getMcpPatternsPath());
+function getMcpTelemetry() {
+  const val = process.env["KAIROS_TELEMETRY"];
+  if (!val || val === "false") return null;
+  return val === "true" ? new TelemetryCollector() : new TelemetryCollector(val);
+}
+function getMcpPatternsPath() {
+  const val = process.env["KAIROS_TELEMETRY"];
+  if (val && val !== "false" && val !== "true") {
+    return (0, import_node_path7.join)(val, "..", "patterns.json");
+  }
+  return (0, import_node_path7.join)((0, import_node_os6.homedir)(), ".kairos", "patterns.json");
+}
+var mcpTelemetry = getMcpTelemetry();
+var mcpSessions = /* @__PURE__ */ new Map();
+var SESSION_TTL_MS = 60 * 60 * 1e3;
+function evictStaleSessions() {
+  const cutoff = Date.now() - SESSION_TTL_MS;
+  for (const [id, session] of mcpSessions) {
+    if (session.startTime < cutoff) mcpSessions.delete(id);
+  }
+}
 function getTelemetryReader() {
   try {
     return new TelemetryReader();
@@ -1703,6 +2756,7 @@ server.tool(
     name: import_zod.z.string().optional().describe("Optional workflow name override")
   },
   async ({ description, name }) => {
+    evictStaleSessions();
     const baseUrl = process.env["N8N_BASE_URL"];
     const apiKey = process.env["N8N_API_KEY"];
     if (!baseUrl || !apiKey) {
@@ -1714,6 +2768,8 @@ server.tool(
         isError: true
       };
     }
+    const runId = generateUUID();
+    const workflowType = inferWorkflowType(description);
     await library.initialize();
     const syncResult = await autoSync();
     const matches = await library.search(description);
@@ -1721,11 +2777,22 @@ server.tool(
     const failureRates = await telemetryReader?.getFailureRates() ?? [];
     const request = { description, ...name ? { name } : {} };
     const built = promptBuilder.build(request, matches, failureRates, syncResult?.catalogText);
+    if (mcpTelemetry) {
+      mcpSessions.set(runId, {
+        description,
+        startTime: Date.now(),
+        validateAttempts: 0,
+        warnedRules: promptBuilder.getWarnedRules(),
+        workflowType
+      });
+      await mcpTelemetry.emit("build_start", { description, model: "mcp-decomposed", dryRun: false }, runId);
+    }
     const systemText = built.system.map((block) => block.text).join("\n\n---\n\n");
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
+          kairos_run_id: runId,
           mode: built.mode,
           matchCount: matches.length,
           topMatchScore: matches[0]?.score ?? null,
@@ -1757,11 +2824,12 @@ server.tool(
 );
 server.tool(
   "kairos_validate",
-  "Validate n8n workflow JSON against 23 structural rules. Returns pass/fail with specific issues. If validation fails, fix the issues and call this again. Errors block deployment; warnings are advisory.",
+  "Validate n8n workflow JSON against 26 structural rules. Returns pass/fail with specific issues. If validation fails, fix the issues and call this again. Errors block deployment; warnings are advisory.",
   {
-    workflow: import_zod.z.string().describe("The workflow JSON string to validate")
+    workflow: import_zod.z.string().describe("The workflow JSON string to validate"),
+    kairos_run_id: import_zod.z.string().optional().describe("Run ID from kairos_prompt \u2014 enables telemetry correlation")
   },
-  async ({ workflow: workflowStr }) => {
+  async ({ workflow: workflowStr, kairos_run_id }) => {
     let parsed;
     try {
       parsed = JSON.parse(workflowStr);
@@ -1779,6 +2847,24 @@ server.tool(
     const result = validator.validate(parsed);
     const errors = result.issues.filter((i) => i.severity === "error");
     const warnings = result.issues.filter((i) => i.severity === "warn");
+    if (mcpTelemetry && kairos_run_id) {
+      const session = mcpSessions.get(kairos_run_id);
+      if (session) {
+        session.validateAttempts++;
+        await mcpTelemetry.emit("generation_attempt", {
+          description: session.description,
+          attempt: session.validateAttempts,
+          temperature: 0,
+          durationMs: 0,
+          tokensInput: 0,
+          tokensOutput: 0,
+          validationPassed: result.valid,
+          issueCount: result.issues.length,
+          issues: result.issues.map((i) => ({ rule: i.rule, severity: i.severity, message: i.message, nodeId: i.nodeId ?? null })),
+          workflowType: session.workflowType
+        }, kairos_run_id);
+      }
+    }
     return {
       content: [{
         type: "text",
@@ -1807,9 +2893,10 @@ server.tool(
   "Deploy a validated workflow to n8n. Pass the workflow JSON that passed kairos_validate. Strips server-assigned fields automatically. Requires N8N_BASE_URL and N8N_API_KEY.",
   {
     workflow: import_zod.z.string().describe("The validated workflow JSON string to deploy"),
-    activate: import_zod.z.boolean().default(false).describe("Activate the workflow immediately after deployment")
+    activate: import_zod.z.boolean().default(false).describe("Activate the workflow immediately after deployment"),
+    kairos_run_id: import_zod.z.string().optional().describe("Run ID from kairos_prompt \u2014 enables telemetry correlation")
   },
-  async ({ workflow: workflowStr, activate }) => {
+  async ({ workflow: workflowStr, activate, kairos_run_id }) => {
     if (!isAllowed("deploy")) {
       return {
         content: [{
@@ -1869,6 +2956,28 @@ server.tool(
       generationMode: "scratch",
       generationAttempts: 1
     });
+    if (mcpTelemetry && kairos_run_id) {
+      const session = mcpSessions.get(kairos_run_id);
+      if (session) {
+        await mcpTelemetry.emit("build_complete", {
+          description: session.description,
+          success: true,
+          totalAttempts: session.validateAttempts,
+          totalDurationMs: Date.now() - session.startTime,
+          totalTokensInput: 0,
+          totalTokensOutput: 0,
+          workflowName: response.name,
+          workflowId: response.id,
+          dryRun: false,
+          credentialsNeeded: 0,
+          warnedRules: session.warnedRules,
+          workflowType: session.workflowType
+        }, kairos_run_id);
+        mcpSessions.delete(kairos_run_id);
+        PatternAnalyzer.fromEnv().analyzeAndSave().catch(() => {
+        });
+      }
+    }
     return {
       content: [{
         type: "text",
@@ -1951,6 +3060,27 @@ server.tool(
     };
   }
 );
+server.tool(
+  "kairos_patterns",
+  "Analyze telemetry data and return failure patterns, build stats, and credential breakdowns. Useful for understanding what goes wrong most often and how to prevent it.",
+  {
+    days: import_zod.z.number().default(30).describe("Number of days of telemetry to analyze"),
+    limit: import_zod.z.number().optional().describe("Maximum number of failure patterns to return")
+  },
+  async ({ days, limit }) => {
+    const analyzer = PatternAnalyzer.fromEnv();
+    const analysis = await analyzer.analyzeAndSave(days);
+    if (limit !== void 0 && limit > 0) {
+      analysis.topFailureRules = analysis.topFailureRules.slice(0, limit);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(analysis, null, 2)
+      }]
+    };
+  }
+);
 server.tool(
   "kairos_list",
   "List all workflows deployed on the connected n8n instance.",