@kairos-sdk/core 0.4.0 → 0.4.5

package/dist/{chunk-NJ6QZBIC.js → chunk-6IXW3WCC.js}

@@ -1,3 +1,8 @@
+// src/utils/uuid.ts
+function generateUUID() {
+  return crypto.randomUUID();
+}
+
 // src/errors/base.ts
 var KairosError = class extends Error {
   constructor(message, cause) {
@@ -397,6 +402,9 @@ 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) {
@@ -529,10 +537,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) {
@@ -541,10 +553,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);
       }
     }
@@ -740,6 +755,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;
@@ -763,470 +848,40 @@ var N8nValidator = class {
   }
 };
 
-// src/generation/prompt-builder.ts
-import { readFileSync } from "fs";
+// src/telemetry/collector.ts
+import { appendFile, mkdir } from "fs/promises";
 import { join } from "path";
 import { homedir } from "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.
-
-## HARD RULES \u2014 violating any of these causes immediate deployment failure
-
-### Forbidden fields \u2014 NEVER include these in the workflow object:
-id, active, createdAt, updatedAt, versionId, meta, isArchived, activeVersionId, activeVersion, pinData, triggerCount, shared, staticData
-
-### Required top-level structure:
-{
-  "name": "<descriptive name>",
-  "nodes": [...],
-  "connections": {...},
-  "settings": {
-    "saveExecutionProgress": true,
-    "saveManualExecutions": true,
-    "saveDataErrorExecution": "all",
-    "saveDataSuccessExecution": "all",
-    "executionTimeout": 3600,
-    "timezone": "UTC",
-    "executionOrder": "v1"
-  }
-}
-
-### Node IDs:
-- Every node.id must be a valid UUID v4 (random hex, format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
-- 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
-
-### Node names:
-- All node names must be unique within the workflow
-- Use descriptive names: "Fetch Open Invoices" not "HTTP Request 2"
-
-### Positioning:
-- Trigger node: [250, 300]
-- Each subsequent step: x + 220 minimum
-- Parallel branches: offset y by \xB1150
-- AI sub-nodes: place below their root node (y + 200)
-
----
-
-## CONNECTION RULES \u2014 the most common source of errors
-
-### Standard connections (main data flow):
-"NodeA": { "main": [ [ { "node": "NodeB", "type": "main", "index": 0 } ] ] }
-
-### AI connections \u2014 CRITICAL: the SUB-NODE is the SOURCE, NOT the agent/chain:
-"OpenAI Chat Model": { "ai_languageModel": [ [ { "node": "AI Agent", "type": "ai_languageModel", "index": 0 } ] ] }
-"Simple Memory":     { "ai_memory":        [ [ { "node": "AI Agent", "type": "ai_memory", "index": 0 } ] ] }
-"Calculator Tool":   { "ai_tool":          [ [ { "node": "AI Agent", "type": "ai_tool", "index": 0 } ] ] }
-
-The AI Agent node does NOT appear in connections as a source for ai_* types.
-Every AI Agent must have at least one ai_languageModel sub-node connected.
-
-### IF node \u2014 two output ports (0 = true, 1 = false):
-"IF Check": { "main": [ [{ "node": "True Path", "type": "main", "index": 0 }], [{ "node": "False Path", "type": "main", "index": 0 }] ] }
-
-### SplitInBatches \u2014 two output ports (0 = done/finished, 1 = loop body per batch):
-Connect output 0 to the node that runs AFTER all batches complete.
-Connect output 1 to the processing chain for each batch. The last node in the chain loops back to SplitInBatches via main input.
-
-### Webhook + RespondToWebhook pattern:
-When webhook responseMode is "responseNode", you MUST include a respondToWebhook node in the flow.
-"Webhook": { "main": [[{ "node": "Process Data", "type": "main", "index": 0 }]] }
-"Process Data": { "main": [[{ "node": "Respond to Webhook", "type": "main", "index": 0 }]] }
-
-### Triggers have no incoming connections.
-### Connection keys are NODE NAMES, never node IDs.
-
-### Nested parameters:
-Node parameters like conditions, assignments, and rule intervals MUST include all required nested fields. Do not leave nested objects empty or partially filled.
-
----
-
-## NODE CATALOG \u2014 exact type strings and safe typeVersions
-
-### Triggers (always at least one required):
-n8n-nodes-base.manualTrigger          typeVersion: 1       \u2014 testing only
-n8n-nodes-base.scheduleTrigger        typeVersion: 1.2     \u2014 params: rule.interval[{field, ...}]
-n8n-nodes-base.webhook                typeVersion: 2       \u2014 params: httpMethod, path, responseMode
-n8n-nodes-base.formTrigger            typeVersion: 2.2
-n8n-nodes-base.emailReadImap          typeVersion: 2       \u2014 cred: imap
-n8n-nodes-base.errorTrigger           typeVersion: 1
-n8n-nodes-base.executeWorkflowTrigger typeVersion: 1.1
-n8n-nodes-base.gmailTrigger           typeVersion: 1.2     \u2014 cred: gmailOAuth2
-n8n-nodes-base.slackTrigger           typeVersion: 1       \u2014 cred: slackApi
-n8n-nodes-base.telegramTrigger        typeVersion: 1.2     \u2014 cred: telegramApi
-n8n-nodes-base.githubTrigger          typeVersion: 1       \u2014 cred: githubApi
-n8n-nodes-base.airtableTrigger        typeVersion: 1       \u2014 cred: airtableTokenApi
-n8n-nodes-base.notionTrigger          typeVersion: 1       \u2014 cred: notionApi
-@n8n/n8n-nodes-langchain.chatTrigger  typeVersion: 1.1     \u2014 pairs with AI Agent
-
-### Core logic:
-n8n-nodes-base.code                   typeVersion: 2       \u2014 params: mode, jsCode
-n8n-nodes-base.httpRequest            typeVersion: 4.2     \u2014 params: method, url, [sendBody, jsonBody, sendHeaders, headerParameters]
-n8n-nodes-base.set                    typeVersion: 3.4     \u2014 params: assignments.assignments[{id, name, value, type}]
-n8n-nodes-base.if                     typeVersion: 2.2     \u2014 params: conditions.conditions[{id, leftValue, rightValue, operator}], combinator
-n8n-nodes-base.switch                 typeVersion: 3.2     \u2014 multi-branch routing
-n8n-nodes-base.filter                 typeVersion: 2.2     \u2014 params: conditions (same as IF), 1 output
-n8n-nodes-base.merge                  typeVersion: 3       \u2014 modes: append/combine/chooseBranch
-n8n-nodes-base.splitInBatches         typeVersion: 3       \u2014 output 0=done, output 1=loop body
-n8n-nodes-base.wait                   typeVersion: 1.1
-n8n-nodes-base.executeWorkflow        typeVersion: 1.2
-n8n-nodes-base.respondToWebhook       typeVersion: 1.1     \u2014 required when webhook responseMode is "responseNode"
-n8n-nodes-base.noOp                   typeVersion: 1
-n8n-nodes-base.splitOut               typeVersion: 1
-n8n-nodes-base.aggregate              typeVersion: 1
-n8n-nodes-base.stickyNote             typeVersion: 1       \u2014 never connected, canvas annotation only
-
-### Email / messaging:
-n8n-nodes-base.emailSend              typeVersion: 2.1     \u2014 cred: smtp
-n8n-nodes-base.slack                  typeVersion: 2.2     \u2014 cred: slackOAuth2Api \u2014 params: resource, operation, select, channelId{__rl}, text
-n8n-nodes-base.telegram               typeVersion: 1.2     \u2014 cred: telegramApi
-n8n-nodes-base.discord                typeVersion: 2       \u2014 cred: discordWebhookApi
-
-### Google:
-n8n-nodes-base.gmail                  typeVersion: 2.1     \u2014 cred: gmailOAuth2 \u2014 params: resource, operation
-n8n-nodes-base.googleSheets           typeVersion: 4.5     \u2014 cred: googleSheetsOAuth2Api \u2014 params: resource, operation, documentId{__rl}, sheetName{__rl}
-n8n-nodes-base.googleDrive            typeVersion: 3       \u2014 cred: googleDriveOAuth2Api
-n8n-nodes-base.googleCalendar         typeVersion: 1.3     \u2014 cred: googleCalendarOAuth2Api
-
-### Productivity:
-n8n-nodes-base.notion                 typeVersion: 2.2     \u2014 cred: notionApi
-n8n-nodes-base.airtable               typeVersion: 2.1     \u2014 cred: airtableTokenApi
-n8n-nodes-base.github                 typeVersion: 1.1     \u2014 cred: githubApi
-n8n-nodes-base.jira                   typeVersion: 1       \u2014 cred: jiraSoftwareCloudApi
-n8n-nodes-base.hubspot                typeVersion: 2.1     \u2014 cred: hubspotOAuth2Api
-
-### Databases:
-n8n-nodes-base.postgres               typeVersion: 2.5     \u2014 cred: postgres
-n8n-nodes-base.mySql                  typeVersion: 2.4     \u2014 cred: mySql
-n8n-nodes-base.redis                  typeVersion: 1       \u2014 cred: redis
-n8n-nodes-base.supabase               typeVersion: 1       \u2014 cred: supabaseApi
-n8n-nodes-base.awsS3                  typeVersion: 2       \u2014 cred: aws
-
-### AI \u2014 Root nodes (sit on main data flow, receive ai_* connections as TARGETS):
-@n8n/n8n-nodes-langchain.agent        typeVersion: 1.9     \u2014 params: promptType, text (if define), options.systemMessage
-@n8n/n8n-nodes-langchain.chainLlm     typeVersion: 1.5
-@n8n/n8n-nodes-langchain.chainRetrievalQa typeVersion: 1.4
-@n8n/n8n-nodes-langchain.openAi       typeVersion: 1.8     \u2014 cred: openAiApi \u2014 standalone node, calls OpenAI directly without sub-nodes
-@n8n/n8n-nodes-langchain.anthropic    typeVersion: 1       \u2014 cred: anthropicApi \u2014 standalone node, calls Anthropic directly without sub-nodes
-
-### AI \u2014 Sub-nodes (sources of ai_* connections, wire INTO root nodes above):
-@n8n/n8n-nodes-langchain.lmChatOpenAi      typeVersion: 1.7  \u2014 cred: openAiApi       \u2014 ai_languageModel \u2014 use with agent/chain, NOT standalone
-@n8n/n8n-nodes-langchain.lmChatAnthropic   typeVersion: 1.3  \u2014 cred: anthropicApi    \u2014 ai_languageModel \u2014 use with agent/chain, NOT standalone
-@n8n/n8n-nodes-langchain.lmChatGoogleGemini typeVersion: 1   \u2014 cred: googlePalmApi   \u2014 ai_languageModel
-@n8n/n8n-nodes-langchain.memoryBufferWindow typeVersion: 1.3  \u2014                       \u2014 ai_memory
-@n8n/n8n-nodes-langchain.toolWorkflow      typeVersion: 2     \u2014                       \u2014 ai_tool
-@n8n/n8n-nodes-langchain.toolCode          typeVersion: 1.1   \u2014                       \u2014 ai_tool
-@n8n/n8n-nodes-langchain.toolHttpRequest   typeVersion: 1.1   \u2014                       \u2014 ai_tool
-@n8n/n8n-nodes-langchain.toolCalculator    typeVersion: 1     \u2014                       \u2014 ai_tool
-
-### Resource locator (__rl) format (Google / Slack / Notion modern nodes):
-{ "__rl": true, "mode": "id", "value": "ACTUAL_ID" }
-{ "__rl": true, "mode": "name", "value": "#channel-name" }
-
-### App node parameter pattern:
-{ "resource": "message", "operation": "send", ...operation-specific fields }
-
-### Schedule Trigger \u2014 daily at 9am example:
-{ "rule": { "interval": [{ "field": "days", "daysInterval": 1, "triggerAtHour": 9, "triggerAtMinute": 0 }] } }
-Cron: { "rule": { "interval": [{ "field": "cronExpression", "expression": "0 9 * * 1-5" }] } }
-
----
+// src/telemetry/types.ts
+var TELEMETRY_SCHEMA_VERSION = 2;
 
-## PRE-DELIVERY SELF-CHECK (do this before calling the tool):
-1. Every connection source/target name exists in nodes array
-2. No duplicate node names
-3. No duplicate node IDs
-4. No forbidden fields at the workflow root
-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"
-
----
-
-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/utils/thresholds.ts
-var DIRECT_THRESHOLD = 0.92;
-var REFERENCE_THRESHOLD = 0.72;
-function scoreToMode(score) {
-  if (score >= DIRECT_THRESHOLD) return "direct";
-  if (score >= REFERENCE_THRESHOLD) return "reference";
-  return "scratch";
-}
-
-// 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",
-  4: "Ensure all node ids are unique \u2014 no two nodes can share the same id",
-  5: "Every node must have a non-empty type string",
-  6: "Every node must have a positive integer typeVersion",
-  7: "Every node must have a position array of exactly [x, y] numbers",
-  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",
-  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" }',
-  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)",
-  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 ?? join(homedir(), ".kairos", "patterns.json");
-  }
-  build(request, matches, globalFailureRates = [], dynamicCatalog) {
-    const mode = this.resolveMode(matches);
-    const system = this.buildSystem(matches, mode, globalFailureRates, dynamicCatalog);
-    const userMessage = this.buildUserMessage(request, matches, mode);
-    return { system, userMessage, mode, matches };
-  }
-  buildCorrectionMessage(request, matches, allIssues, attempt) {
-    const base = this.buildUserMessage(request, matches, this.resolveMode(matches));
-    return `${base}
-
-IMPORTANT: A previous generation attempt (attempt ${attempt}) failed validation with these issues:
-${allIssues.join("\n")}
-
-Fix ALL of the above issues in your new response. Do not repeat any of these mistakes.`;
-  }
-  resolveMode(matches) {
-    if (matches.length === 0) return "scratch";
-    const top = matches[0];
-    if (!top) return "scratch";
-    return scoreToMode(top.score);
-  }
-  buildSystem(matches, mode, globalFailureRates = [], dynamicCatalog) {
-    let basePrompt = SYSTEM_PROMPT_V1;
-    if (dynamicCatalog) {
-      basePrompt = basePrompt.replace(
-        /## NODE CATALOG — exact type strings and safe typeVersions[\s\S]*?(?=## PRE-DELIVERY SELF-CHECK)/,
-        dynamicCatalog + "\n\n"
-      );
-    }
-    const blocks = [
-      {
-        type: "text",
-        text: basePrompt,
-        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)})
-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");
-        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:
-
-${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
-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 });
-    }
-    return blocks;
-  }
-  loadPatterns() {
-    try {
-      const raw = 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"
+// src/telemetry/collector.ts
+var TelemetryCollector = class {
+  dir;
+  sessionId;
+  dirReady = null;
+  constructor(dir) {
+    this.dir = dir ?? join(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
     };
-    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_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_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)`);
+    if (!this.dirReady) {
+      this.dirReady = mkdir(this.dir, { recursive: true }).then(() => {
+      });
     }
-    if (lines.length === 0) return null;
-    const unique = [...new Set(lines)];
-    return `## Known Failure Patterns \u2014 AVOID THESE
-
-Previous builds frequently failed the following validation rules. Ensure your output does NOT repeat these mistakes:
-${unique.join("\n")}`;
-  }
-  buildUserMessage(request, _matches, _mode) {
-    const namePart = request.name ? `
-Workflow name: "${request.name}"` : "";
-    return `Build a workflow that: ${request.description}${namePart}`;
+    await this.dirReady;
+    const filename = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ".jsonl";
+    const filepath = join(this.dir, filename);
+    await appendFile(filepath, JSON.stringify(event) + "\n", "utf-8");
   }
 };
 
@@ -1334,13 +989,93 @@ var TelemetryReader = class {
 };
 
 // src/telemetry/pattern-analyzer.ts
-import { writeFile, readFile as fsReadFile, appendFile, mkdir, rename } from "fs/promises";
+import { writeFile, readFile as fsReadFile, appendFile as appendFile2, mkdir as mkdir2, rename } from "fs/promises";
 import { join as join4 } from "path";
 import { homedir as homedir3 } from "os";
+
+// 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",
+  4: "Ensure all node ids are unique \u2014 no two nodes can share the same id",
+  5: "Every node must have a non-empty type string",
+  6: "Every node must have a positive integer typeVersion",
+  7: "Every node must have a position array of exactly [x, y] numbers",
+  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",
+  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: '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)",
+  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/telemetry/pattern-analyzer.ts
 var PATTERN_SCHEMA_VERSION = 2;
 var PatternAnalyzer = class _PatternAnalyzer {
   telemetryDir;
   outputDir;
+  _cachedEvents = null;
   constructor(telemetryDir) {
     const defaultDir = join4(homedir3(), ".kairos", "telemetry");
     this.telemetryDir = telemetryDir ?? defaultDir;
@@ -1369,19 +1104,23 @@ var PatternAnalyzer = class _PatternAnalyzer {
       }));
     }
     if (fromVersion < 2) {
-      migrated = migrated.map((p) => ({
-        ...p,
-        scoringFactors: {
-          ...p.scoringFactors,
-          stickinessBoost: p.scoringFactors.stickinessBoost ?? p.scoringFactors["validationBoost"] ?? 0
-        }
-      }));
+      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(
@@ -1394,13 +1133,18 @@ var PatternAnalyzer = class _PatternAnalyzer {
     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 ?? []) {
-        const entry = ruleFailures.get(issue.rule) ?? { count: 0, sessions: /* @__PURE__ */ new Set(), recencyWeights: [], allMessages: [] };
+        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(a.sessionId);
+        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 = [
@@ -1453,9 +1197,10 @@ var PatternAnalyzer = class _PatternAnalyzer {
     }
     const sessions = /* @__PURE__ */ new Map();
     for (const a of attempts) {
-      const list = sessions.get(a.sessionId) ?? [];
+      const buildId = a.runId ?? a.sessionId;
+      const list = sessions.get(buildId) ?? [];
       list.push(a);
-      sessions.set(a.sessionId, list);
+      sessions.set(buildId, list);
     }
     let firstTryPass = 0;
     let correctionNeeded = 0;
@@ -1502,7 +1247,7 @@ var PatternAnalyzer = class _PatternAnalyzer {
       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 {
+      const pattern = {
         rule,
         failureCount: entry.count,
         confidence: Math.round(rawConfidence * 1e3) / 1e3,
@@ -1514,6 +1259,10 @@ var PatternAnalyzer = class _PatternAnalyzer {
         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) {
@@ -1570,7 +1319,7 @@ var PatternAnalyzer = class _PatternAnalyzer {
       const warned = bcData.warnedRules ?? [];
       if (warned.length === 0) continue;
       const sessionFailedRules = /* @__PURE__ */ new Set();
-      const sessionAttempts = sessions.get(bc.sessionId) ?? [];
+      const sessionAttempts = sessions.get(bc.runId ?? bc.sessionId) ?? [];
       for (const a of sessionAttempts) {
         const ad = a.data;
         if (ad.validationPassed === false) {
@@ -1637,7 +1386,7 @@ var PatternAnalyzer = class _PatternAnalyzer {
   }
   async analyzeAndSave(days = 30) {
     const analysis = await this.analyze(days);
-    await mkdir(this.outputDir, { recursive: true });
+    await mkdir2(this.outputDir, { recursive: true });
     const outputPath = join4(this.outputDir, "patterns.json");
     const tmpPath = `${outputPath}.tmp`;
     await writeFile(tmpPath, JSON.stringify(analysis, null, 2), "utf-8");
@@ -1652,9 +1401,56 @@ var PatternAnalyzer = class _PatternAnalyzer {
       topRules: analysis.topFailureRules.filter((p) => p.state !== "resolved").slice(0, 5).map((p) => ({ rule: p.rule, compositeScore: p.compositeScore, state: p.state }))
     };
     const historyPath = join4(this.outputDir, "pattern-history.jsonl");
-    await appendFile(historyPath, JSON.stringify(historySummary) + "\n", "utf-8");
+    await appendFile2(historyPath, JSON.stringify(historySummary) + "\n", "utf-8");
+    const sessions = await this.buildSessionSummaries(days);
+    const sessionHistoryPath = join4(this.outputDir, "session-history.json");
+    const sessionHistoryTmp = `${sessionHistoryPath}.tmp`;
+    await writeFile(sessionHistoryTmp, JSON.stringify(sessions, null, 2), "utf-8");
+    await rename(sessionHistoryTmp, sessionHistoryPath);
     return analysis;
   }
+  async getSessions(limit = 20) {
+    try {
+      const raw = await fsReadFile(join4(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 fsReadFile(join4(this.outputDir, "pattern-history.jsonl"), "utf-8");
@@ -1676,7 +1472,7 @@ var PatternAnalyzer = class _PatternAnalyzer {
         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)`
+          message: `Pattern references Rule ${p.rule} which does not exist in the current validator (rules 1-26)`
         });
       }
     }
@@ -1979,13 +1775,17 @@ function rerank(candidates, clusters) {
 }
 
 // src/library/file-library.ts
-import { readFile, writeFile as writeFile2, rename as rename2, mkdir as mkdir2 } from "fs/promises";
+import { readFile, writeFile as writeFile2, rename as rename2, mkdir as mkdir3, stat } from "fs/promises";
 import { join as join5 } from "path";
 import { homedir as homedir4 } from "os";
 
-// src/utils/uuid.ts
-function generateUUID() {
-  return crypto.randomUUID();
+// src/utils/thresholds.ts
+var DIRECT_THRESHOLD = 0.92;
+var REFERENCE_THRESHOLD = 0.72;
+function scoreToMode(score) {
+  if (score >= DIRECT_THRESHOLD) return "direct";
+  if (score >= REFERENCE_THRESHOLD) return "reference";
+  return "scratch";
 }
 
 // src/library/file-library.ts
@@ -2001,14 +1801,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 ?? join5(homedir4(), ".kairos", "library");
   }
+  get workflowsDir() {
+    return join5(this.dir, "workflows");
+  }
+  workflowFilePath(id) {
+    return join5(this.workflowsDir, `${id}.json`);
+  }
   async initialize() {
     if (!this.initPromise) {
       this.initPromise = this.doInitialize();
@@ -2016,62 +1830,149 @@ var FileLibrary = class {
     return this.initPromise;
   }
   async doInitialize() {
-    await mkdir2(this.dir, { recursive: true });
+    await mkdir3(this.dir, { recursive: true });
     const indexPath = join5(this.dir, "index.json");
+    let workflowsDirExists = false;
     try {
-      const raw = await 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 stat(this.workflowsDir);
+      workflowsDirExists = true;
+    } catch {
+    }
+    if (workflowsDirExists) {
+      try {
+        const raw = await 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 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 mkdir3(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 mkdir3(this.workflowsDir, { recursive: true });
+    const newMeta = [];
+    for (const entry of oldEntries) {
+      const wfPath = this.workflowFilePath(entry.id);
+      const tmpPath = `${wfPath}.tmp`;
+      await writeFile2(tmpPath, JSON.stringify(entry.workflow), "utf-8");
+      await rename2(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 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 writeFile2(tmpPath, JSON.stringify(workflow), "utf-8");
+    await rename2(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 } : {},
@@ -2083,31 +1984,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++;
@@ -2115,24 +2020,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;
@@ -2147,11 +2063,36 @@ var FileLibrary = class {
     }
     return [...map.values()];
   }
+  /**
+   * Direct write used only during migration (before writeQueue is needed).
+   */
+  async persistNow() {
+    const indexPath = join5(this.dir, "index.json");
+    const tmpPath = `${indexPath}.tmp`;
+    await writeFile2(tmpPath, JSON.stringify(this.meta, null, 2), "utf-8");
+    await rename2(tmpPath, indexPath);
+  }
   persist() {
     this.writeQueue = this.writeQueue.then(async () => {
       const indexPath = join5(this.dir, "index.json");
+      let onDisk = [];
+      try {
+        const raw = await 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 writeFile2(tmpPath, JSON.stringify(this.workflows, null, 2), "utf-8");
+      await writeFile2(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
       await rename2(tmpPath, indexPath);
     });
     return this.writeQueue;
@@ -2169,7 +2110,9 @@ export {
   NodeRegistry,
   N8nValidator,
   scoreToMode,
-  PromptBuilder,
+  RULE_EXAMPLES,
+  RULE_MITIGATIONS,
+  TelemetryCollector,
   TelemetryReader,
   PatternAnalyzer,
   nullLogger,
@@ -2180,4 +2123,4 @@ export {
   buildSearchCorpus,
   FileLibrary
 };
-//# sourceMappingURL=chunk-NJ6QZBIC.js.map
+//# sourceMappingURL=chunk-6IXW3WCC.js.map