@kairos-sdk/core 0.4.0 → 0.5.0

package/dist/standalone.cjs

@@ -0,0 +1,2978 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/standalone.ts
+var standalone_exports = {};
+__export(standalone_exports, {
+  ApiError: () => ApiError,
+  DEFAULT_REGISTRY: () => DEFAULT_REGISTRY,
+  FileLibrary: () => FileLibrary,
+  GenerationError: () => GenerationError,
+  GuardError: () => GuardError,
+  KairosError: () => KairosError,
+  N8nApiClient: () => N8nApiClient,
+  N8nFieldStripper: () => N8nFieldStripper,
+  N8nProvider: () => N8nProvider,
+  N8nValidator: () => N8nValidator,
+  NodeRegistry: () => NodeRegistry,
+  NullLibrary: () => NullLibrary,
+  PatternAnalyzer: () => PatternAnalyzer,
+  ProviderError: () => ProviderError,
+  ResponseParseError: () => ResponseParseError,
+  TelemetryCollector: () => TelemetryCollector,
+  TelemetryReader: () => TelemetryReader,
+  TemplateSyncer: () => TemplateSyncer,
+  ValidationError: () => ValidationError,
+  buildSearchCorpus: () => buildSearchCorpus,
+  clusterWorkflows: () => clusterWorkflows,
+  hybridScore: () => hybridScore,
+  nullLogger: () => nullLogger,
+  rerank: () => rerank,
+  tokenize: () => tokenize
+});
+module.exports = __toCommonJS(standalone_exports);
+
+// src/errors/base.ts
+var KairosError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "KairosError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  cause;
+};
+
+// src/errors/guard-error.ts
+var GuardError = class extends KairosError {
+  constructor(message) {
+    super(message);
+    this.name = "GuardError";
+  }
+};
+
+// src/errors/provider-error.ts
+var ProviderError = class extends KairosError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ProviderError";
+  }
+};
+
+// src/providers/n8n/provider.ts
+var SMOKE_TEST_TIMEOUT_MS = 3e4;
+var SMOKE_TEST_POLL_INTERVAL_MS = 1e3;
+var N8nProvider = class {
+  constructor(client, stripper) {
+    this.client = client;
+    this.stripper = stripper;
+  }
+  client;
+  stripper;
+  platform = "n8n";
+  async deploy(workflow) {
+    const stripped = this.stripper.stripForCreate(workflow);
+    const response = await this.client.createWorkflow(stripped);
+    return { workflowId: response.id, name: response.name };
+  }
+  async update(id, workflow) {
+    const stripped = this.stripper.stripForUpdate(workflow);
+    const response = await this.client.updateWorkflow(id, stripped);
+    return { workflowId: response.id, name: response.name };
+  }
+  async get(id) {
+    const response = await this.client.getWorkflow(id);
+    return {
+      name: response.name,
+      nodes: response.nodes,
+      connections: response.connections,
+      ...response.settings !== void 0 ? { settings: response.settings } : {},
+      ...response.tags !== void 0 ? { tags: response.tags } : {}
+    };
+  }
+  async list() {
+    return this.client.listWorkflows();
+  }
+  async activate(id) {
+    await this.client.activateWorkflow(id);
+  }
+  async deactivate(id) {
+    await this.client.deactivateWorkflow(id);
+  }
+  async delete(id, options) {
+    if (options.confirm !== true) {
+      throw new GuardError("delete() requires { confirm: true } to prevent accidental deletion");
+    }
+    await this.client.deleteWorkflow(id);
+  }
+  async executions(workflowId, filter) {
+    return this.client.getExecutions(workflowId, filter);
+  }
+  async execution(id) {
+    return this.client.getExecution(id);
+  }
+  async listTags() {
+    return this.client.listTags();
+  }
+  async createTag(name) {
+    return this.client.createTag(name);
+  }
+  async tag(workflowId, tagIds) {
+    await this.client.tagWorkflow(workflowId, tagIds);
+  }
+  async untag(workflowId, tagIds) {
+    await this.client.untagWorkflow(workflowId, tagIds);
+  }
+  async smokeTest(workflowId, workflow) {
+    const start = Date.now();
+    const trigger = this.detectTrigger(workflow);
+    if (trigger.type === "unsupported") {
+      return { status: "not-applicable", triggerType: "not-applicable" };
+    }
+    if (trigger.type === "manual") {
+      let executionId;
+      try {
+        executionId = await this.client.triggerManual(workflowId);
+      } catch (err) {
+        return { status: "error", triggerType: "manual", durationMs: Date.now() - start, error: String(err) };
+      }
+      try {
+        const execution = await this.pollExecution(executionId);
+        const durationMs = Date.now() - start;
+        if (execution.status === "success") {
+          return { status: "passed", triggerType: "manual", executionId, durationMs };
+        }
+        return {
+          status: "failed",
+          triggerType: "manual",
+          executionId,
+          durationMs,
+          error: `Execution ended with status: ${execution.status}`
+        };
+      } catch (err) {
+        return { status: "error", triggerType: "manual", executionId, durationMs: Date.now() - start, error: String(err) };
+      }
+    }
+    try {
+      const statusCode = await this.client.triggerWebhookTest(trigger.path);
+      const durationMs = Date.now() - start;
+      if (statusCode >= 200 && statusCode < 300) {
+        return { status: "passed", triggerType: "webhook", durationMs };
+      }
+      return { status: "failed", triggerType: "webhook", durationMs, error: `Webhook returned HTTP ${statusCode}` };
+    } catch (err) {
+      return { status: "error", triggerType: "webhook", durationMs: Date.now() - start, error: String(err) };
+    }
+  }
+  detectTrigger(workflow) {
+    for (const node of workflow.nodes) {
+      if (node.type === "n8n-nodes-base.manualTrigger") return { type: "manual" };
+      if (node.type === "n8n-nodes-base.webhook") {
+        const params = node.parameters;
+        const path = typeof params?.["path"] === "string" ? params["path"] : "webhook";
+        return { type: "webhook", path };
+      }
+    }
+    return { type: "unsupported" };
+  }
+  async pollExecution(executionId) {
+    const deadline = Date.now() + SMOKE_TEST_TIMEOUT_MS;
+    for (; ; ) {
+      const execution = await this.client.getExecution(executionId);
+      if (execution.status !== "running" && execution.status !== "waiting") {
+        return execution;
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await new Promise((resolve) => setTimeout(resolve, Math.min(SMOKE_TEST_POLL_INTERVAL_MS, remaining)));
+    }
+    throw new ProviderError(`Smoke test: execution ${executionId} did not complete within ${SMOKE_TEST_TIMEOUT_MS}ms`);
+  }
+};
+
+// src/errors/api-error.ts
+var ApiError = class extends KairosError {
+  constructor(message, statusCode, cause) {
+    super(message, cause);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+  statusCode;
+};
+
+// src/utils/retry.ts
+function isTransientNetworkError(err) {
+  const TRANSIENT_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "ENOTFOUND", "ECONNABORTED"]);
+  let current = err;
+  for (let i = 0; i < 4; i++) {
+    if (current === null || typeof current !== "object") break;
+    const code = current.code;
+    if (typeof code === "string" && TRANSIENT_CODES.has(code)) return true;
+    current = current.cause;
+  }
+  return false;
+}
+async function withRetry(fn, maxAttempts, delayMs, shouldRetry) {
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (attempt > 0) {
+      const jitter = Math.random() * delayMs * 0.5;
+      await new Promise((resolve) => setTimeout(resolve, delayMs * 2 ** (attempt - 1) + jitter));
+    }
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (shouldRetry && !shouldRetry(err)) throw err;
+    }
+  }
+  throw lastError;
+}
+function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return fetch(url, { ...init, signal: controller.signal }).finally(() => clearTimeout(timer));
+}
+
+// src/providers/n8n/api-client.ts
+var EXECUTION_LIMIT_CAP = 100;
+var N8N_API_PAGE_SIZE = 250;
+var REQUEST_TIMEOUT_MS = 3e4;
+var RETRY_ATTEMPTS = 3;
+var RETRY_DELAY_MS = 1e3;
+var N8nApiClient = class {
+  constructor(baseUrl, apiKey, logger) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.logger = logger;
+    if (!baseUrl || typeof baseUrl !== "string") {
+      throw new GuardError("N8nApiClient: baseUrl must be a non-empty string");
+    }
+    try {
+      new URL(baseUrl);
+    } catch {
+      throw new GuardError(`N8nApiClient: baseUrl is not a valid URL: "${baseUrl}"`);
+    }
+    if (!apiKey || typeof apiKey !== "string") {
+      throw new GuardError("N8nApiClient: apiKey must be a non-empty string");
+    }
+  }
+  baseUrl;
+  apiKey;
+  logger;
+  async request(method, path, body) {
+    const url = `${this.baseUrl.replace(/\/$/, "")}/api/v1${path}`;
+    this.logger.debug(`n8n ${method} ${path}`);
+    const isSafe = method === "GET";
+    if (!isSafe) {
+      return withRetry(
+        () => this.singleRequest(url, method, path, body),
+        2,
+        RETRY_DELAY_MS,
+        isTransientNetworkError
+      );
+    }
+    return withRetry(
+      () => this.singleRequest(url, method, path, body),
+      RETRY_ATTEMPTS,
+      RETRY_DELAY_MS,
+      (err) => err instanceof ProviderError || err instanceof ApiError && err.statusCode === 429
+    );
+  }
+  async singleRequest(url, method, path, body) {
+    let response;
+    try {
+      response = await fetchWithTimeout(url, {
+        method,
+        headers: {
+          "X-N8N-API-KEY": this.apiKey,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      }, REQUEST_TIMEOUT_MS);
+    } catch (err) {
+      throw new ProviderError(`Network error calling n8n API: ${path}`, err);
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = await response.text().catch(() => "");
+      }
+      this.logger.error(`n8n API error ${response.status} on ${method} ${path}`, {
+        status: response.status,
+        body: String(errorBody)
+      });
+      throw new ApiError(
+        `n8n API returned ${response.status} for ${method} ${path}: ${JSON.stringify(errorBody)}`,
+        response.status,
+        errorBody
+      );
+    }
+    if (response.status === 204) return void 0;
+    return response.json();
+  }
+  async createWorkflow(workflow) {
+    return this.request("POST", "/workflows", workflow);
+  }
+  async updateWorkflow(id, workflow) {
+    return this.request("PUT", `/workflows/${id}`, workflow);
+  }
+  async getWorkflow(id) {
+    return this.request("GET", `/workflows/${id}`);
+  }
+  async listWorkflows() {
+    const all = [];
+    let path = `/workflows?limit=${N8N_API_PAGE_SIZE}`;
+    for (; ; ) {
+      const response = await this.request("GET", path);
+      for (const w of response.data) {
+        all.push({
+          id: w.id,
+          name: w.name,
+          active: w.active,
+          createdAt: w.createdAt,
+          updatedAt: w.updatedAt,
+          ...w.tags !== void 0 ? { tags: w.tags } : {}
+        });
+      }
+      if (!response.nextCursor) break;
+      path = `/workflows?limit=${N8N_API_PAGE_SIZE}&cursor=${response.nextCursor}`;
+    }
+    return all;
+  }
+  async deleteWorkflow(id) {
+    await this.request("DELETE", `/workflows/${id}`);
+  }
+  async activateWorkflow(id) {
+    await this.request("POST", `/workflows/${id}/activate`);
+  }
+  async deactivateWorkflow(id) {
+    await this.request("POST", `/workflows/${id}/deactivate`);
+  }
+  async getExecutions(workflowId, filter) {
+    const params = new URLSearchParams();
+    if (workflowId) params.set("workflowId", workflowId);
+    if (filter?.status) params.set("status", filter.status);
+    const limit = Math.min(filter?.limit ?? 20, EXECUTION_LIMIT_CAP);
+    params.set("limit", String(limit));
+    if (filter?.cursor) params.set("cursor", filter.cursor);
+    const qs = params.toString();
+    const response = await this.request("GET", `/executions${qs ? `?${qs}` : ""}`);
+    return response.data.map(this.mapExecution);
+  }
+  async getExecution(id) {
+    const response = await this.request("GET", `/executions/${id}`);
+    return { ...this.mapExecution(response), data: response.data, workflowData: response.workflowData };
+  }
+  async listTags() {
+    const all = [];
+    let path = `/tags?limit=${N8N_API_PAGE_SIZE}`;
+    for (; ; ) {
+      const response = await this.request("GET", path);
+      for (const t of response.data) {
+        all.push({ id: t.id, name: t.name });
+      }
+      if (!response.nextCursor) break;
+      path = `/tags?limit=${N8N_API_PAGE_SIZE}&cursor=${response.nextCursor}`;
+    }
+    return all;
+  }
+  async createTag(name) {
+    const response = await this.request("POST", "/tags", { name });
+    return { id: response.id, name: response.name };
+  }
+  async tagWorkflow(workflowId, tagIds) {
+    await this.request("PUT", `/workflows/${workflowId}/tags`, tagIds.map((id) => ({ id })));
+  }
+  async untagWorkflow(workflowId, tagIds) {
+    const current = await this.getWorkflow(workflowId);
+    const remaining = (current.tags ?? []).filter((t) => !tagIds.includes(t.id)).map((t) => ({ id: t.id }));
+    await this.request("PUT", `/workflows/${workflowId}/tags`, remaining);
+  }
+  async getNodeTypes() {
+    try {
+      const response = await this.request("GET", "/node-types");
+      return response.data ?? response;
+    } catch {
+      return [];
+    }
+  }
+  async triggerManual(workflowId) {
+    const raw = await this.request("POST", `/workflows/${workflowId}/run`);
+    const inner = raw["data"];
+    const execId = inner?.["executionId"] ?? raw["executionId"];
+    if (execId === void 0 || execId === null) {
+      throw new ProviderError(
+        `n8n trigger response missing executionId \u2014 got: ${JSON.stringify(raw)}`
+      );
+    }
+    return String(execId);
+  }
+  async triggerWebhookTest(path) {
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
+    const url = `${this.baseUrl.replace(/\/$/, "")}/webhook-test${cleanPath}`;
+    this.logger.debug(`n8n POST webhook-test ${cleanPath}`);
+    try {
+      const response = await fetchWithTimeout(
+        url,
+        { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) },
+        REQUEST_TIMEOUT_MS
+      );
+      return response.status;
+    } catch (err) {
+      throw new ProviderError(`Webhook test request failed for path "${path}"`, err);
+    }
+  }
+  mapExecution(e) {
+    return {
+      id: e.id,
+      workflowId: e.workflowId,
+      status: e.status,
+      startedAt: e.startedAt,
+      ...e.stoppedAt !== void 0 ? { stoppedAt: e.stoppedAt } : {},
+      mode: e.mode
+    };
+  }
+};
+
+// src/providers/n8n/types.ts
+var FORBIDDEN_ON_CREATE = [
+  "id",
+  "createdAt",
+  "updatedAt",
+  "versionId",
+  "meta",
+  "isArchived",
+  "activeVersionId",
+  "activeVersion",
+  "active",
+  "pinData",
+  "triggerCount",
+  "shared",
+  "staticData"
+];
+var FORBIDDEN_ON_UPDATE = FORBIDDEN_ON_CREATE.filter((f) => f !== "id");
+
+// src/providers/n8n/stripper.ts
+var N8nFieldStripper = class {
+  stripForCreate(workflow) {
+    return this.strip(workflow, FORBIDDEN_ON_CREATE);
+  }
+  stripForUpdate(workflow) {
+    return this.strip(workflow, FORBIDDEN_ON_UPDATE);
+  }
+  strip(workflow, forbidden) {
+    const result = { ...workflow };
+    for (const field of forbidden) {
+      delete result[field];
+    }
+    return result;
+  }
+};
+
+// src/utils/uuid.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+
+// src/library/null-library.ts
+var NullLibrary = class {
+  async initialize() {
+  }
+  async search(_description, _options) {
+    return [];
+  }
+  async save(_workflow, _metadata) {
+    return generateUUID();
+  }
+  async recordDeployment(_id) {
+  }
+  async recordOutcome(_id, _outcome) {
+  }
+  async get(_id) {
+    return null;
+  }
+  async list(_filters) {
+    return [];
+  }
+};
+
+// src/library/file-library.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_os = require("os");
+
+// 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/scorer.ts
+function loadWeights() {
+  const raw = {
+    tfidf: parseFloat(process.env["KAIROS_WEIGHT_TFIDF"] ?? ""),
+    nodeFingerprint: parseFloat(process.env["KAIROS_WEIGHT_JACCARD"] ?? ""),
+    outcome: parseFloat(process.env["KAIROS_WEIGHT_OUTCOME"] ?? ""),
+    deploy: parseFloat(process.env["KAIROS_WEIGHT_DEPLOY"] ?? "")
+  };
+  const defaults = { tfidf: 0.35, nodeFingerprint: 0.3, outcome: 0.2, deploy: 0.15 };
+  const anySet = Object.values(raw).some((v) => !isNaN(v) && v >= 0);
+  if (!anySet) return defaults;
+  const w = {
+    tfidf: !isNaN(raw.tfidf) && raw.tfidf >= 0 ? raw.tfidf : defaults.tfidf,
+    nodeFingerprint: !isNaN(raw.nodeFingerprint) && raw.nodeFingerprint >= 0 ? raw.nodeFingerprint : defaults.nodeFingerprint,
+    outcome: !isNaN(raw.outcome) && raw.outcome >= 0 ? raw.outcome : defaults.outcome,
+    deploy: !isNaN(raw.deploy) && raw.deploy >= 0 ? raw.deploy : defaults.deploy
+  };
+  const total = w.tfidf + w.nodeFingerprint + w.outcome + w.deploy;
+  if (total <= 0) return defaults;
+  return {
+    tfidf: w.tfidf / total,
+    nodeFingerprint: w.nodeFingerprint / total,
+    outcome: w.outcome / total,
+    deploy: w.deploy / total
+  };
+}
+var WEIGHTS = loadWeights();
+var NODE_KEYWORDS = {
+  slack: ["slack", "slackApi"],
+  email: ["gmail", "sendEmail", "emailSend", "emailReadImap"],
+  webhook: ["webhook", "webhookTrigger"],
+  schedule: ["scheduleTrigger", "cron"],
+  http: ["httpRequest"],
+  sheets: ["googleSheets"],
+  github: ["github", "githubTrigger"],
+  telegram: ["telegram", "telegramTrigger"],
+  ai: ["agent", "openAi", "lmChatOpenAi", "lmChatAnthropic", "chainLlm", "chainSummarization"],
+  memory: ["memoryBufferWindow", "memoryXata", "memoryPostgres"],
+  vector: ["vectorStoreInMemory", "vectorStorePinecone", "vectorStoreQdrant"],
+  database: ["postgres", "mySql", "redis", "mongoDb"],
+  airtable: ["airtable"],
+  notion: ["notion"],
+  s3: ["awsS3"],
+  code: ["code"],
+  merge: ["merge"],
+  switch: ["switch"],
+  if: ["if"],
+  wait: ["wait"],
+  rss: ["rssFeedRead", "rssFeedReadTrigger"],
+  form: ["formTrigger"],
+  set: ["set"],
+  split: ["splitInBatches"],
+  filter: ["filter"],
+  telegram_trigger: ["telegramTrigger"],
+  stripe: ["stripe"]
+};
+function extractQueryFingerprint(description) {
+  const lower = description.toLowerCase();
+  const matches = /* @__PURE__ */ new Set();
+  for (const [keyword, nodeTypes] of Object.entries(NODE_KEYWORDS)) {
+    if (lower.includes(keyword)) {
+      for (const nt of nodeTypes) matches.add(nt);
+    }
+  }
+  if (/\bevery\b|\bdaily\b|\bhourly\b|\bweekly\b|\bmonthly\b|\bcron\b|\bschedule\b|\bat \d/.test(lower)) {
+    matches.add("scheduleTrigger");
+  }
+  if (/\bwebhook\b|\breceive\b.*\bpost\b|\bpost\b.*\brequest\b/.test(lower)) {
+    matches.add("webhook");
+  }
+  if (/\bchat\b|\bchatbot\b|\bconversation\b/.test(lower)) {
+    matches.add("chatTrigger");
+  }
+  if (/\bai\b|\bllm\b|\bgpt\b|\bclaude\b|\bagent\b|\bsummariz/.test(lower)) {
+    matches.add("agent");
+  }
+  return matches;
+}
+function extractWorkflowFingerprint(w) {
+  const fp = /* @__PURE__ */ new Set();
+  for (const node of w.workflow.nodes) {
+    const bare = node.type.split(".").pop() ?? "";
+    fp.add(bare);
+  }
+  return fp;
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const item of a) {
+    if (b.has(item)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+function outcomeScore(w) {
+  const stats = w.outcomeStats;
+  if (!stats || stats.totalUses === 0) return 0.5;
+  const passRate = stats.firstTryPasses / stats.totalUses;
+  const avgAttempts = stats.totalAttempts / stats.totalUses;
+  const attemptPenalty = Math.max(0, 1 - (avgAttempts - 1) * 0.3);
+  return passRate * 0.6 + attemptPenalty * 0.4;
+}
+function deployScore(w) {
+  return 1 + Math.log(w.deployCount + 1) * 0.1;
+}
+function hybridScore(queryTokens, queryDescription, workflows, docTokenArrays, idf) {
+  const queryFp = extractQueryFingerprint(queryDescription);
+  const ceiling = queryTokens.reduce((sum, qt) => sum + (idf.get(qt) ?? 0), 0) || 1;
+  return workflows.map((w, i) => {
+    const docTokens = docTokenArrays[i];
+    let tfidfRaw = 0;
+    const docFreq = /* @__PURE__ */ new Map();
+    for (const t of docTokens) {
+      docFreq.set(t, (docFreq.get(t) ?? 0) + 1);
+    }
+    for (const qt of queryTokens) {
+      const tf = docTokens.length > 0 ? (docFreq.get(qt) ?? 0) / docTokens.length : 0;
+      const idfVal = idf.get(qt) ?? 0;
+      tfidfRaw += tf * idfVal;
+    }
+    const tfidf = Math.min(tfidfRaw / ceiling, 1);
+    const workflowFp = extractWorkflowFingerprint(w);
+    const nodeFingerprint = queryFp.size > 0 ? jaccardSimilarity(queryFp, workflowFp) : 0;
+    const outcome = outcomeScore(w);
+    const deploy = Math.min(deployScore(w), 1.5) / 1.5;
+    const score = Math.min(
+      WEIGHTS.tfidf * tfidf + WEIGHTS.nodeFingerprint * nodeFingerprint + WEIGHTS.outcome * outcome + WEIGHTS.deploy * deploy,
+      1
+    );
+    return {
+      workflow: w,
+      score,
+      signals: { tfidf, nodeFingerprint, outcome, deploy }
+    };
+  });
+}
+
+// src/library/cluster.ts
+function getFingerprint(w) {
+  return w.workflow.nodes.map((n) => n.type.split(".").pop() ?? "").sort();
+}
+function fingerprintKey(fp) {
+  return fp.join("|");
+}
+function describePattern(fp) {
+  const triggers = fp.filter((n) => /trigger/i.test(n));
+  const outputs = fp.filter((n) => /slack|gmail|email|telegram|sheets|airtable|notion/i.test(n));
+  const ai = fp.filter((n) => /agent|openai|anthropic|chain|memory/i.test(n));
+  const core = fp.filter((n) => /httpRequest|code|merge|switch|if|set|filter/i.test(n));
+  const parts = [];
+  if (triggers.length > 0) parts.push(triggers[0]);
+  if (ai.length > 0) parts.push("AI");
+  if (core.length > 0) parts.push(core.slice(0, 2).join("+"));
+  if (outputs.length > 0) parts.push(outputs[0]);
+  return parts.length > 0 ? parts.join(" \u2192 ") : fp.slice(0, 3).join(" \u2192 ");
+}
+function clusterWorkflows(workflows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const w of workflows) {
+    const fp = getFingerprint(w);
+    const key = fingerprintKey(fp);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(w);
+    } else {
+      groups.set(key, [w]);
+    }
+  }
+  const clusters = [];
+  for (const [, members] of groups) {
+    if (members.length === 0) continue;
+    const fp = getFingerprint(members[0]);
+    const withStats = members.filter((m) => m.outcomeStats && m.outcomeStats.totalUses > 0);
+    let avgFirstTryPassRate = 0;
+    let avgAttempts = 0;
+    if (withStats.length > 0) {
+      avgFirstTryPassRate = withStats.reduce((sum, m) => {
+        const s = m.outcomeStats;
+        return sum + s.firstTryPasses / s.totalUses;
+      }, 0) / withStats.length;
+      avgAttempts = withStats.reduce((sum, m) => {
+        const s = m.outcomeStats;
+        return sum + s.totalAttempts / s.totalUses;
+      }, 0) / withStats.length;
+    }
+    const ruleCounts = /* @__PURE__ */ new Map();
+    let totalFailureInstances = 0;
+    for (const m of withStats) {
+      const rules = m.outcomeStats.failedRules;
+      for (const [rule, count] of Object.entries(rules)) {
+        const r = parseInt(rule, 10);
+        ruleCounts.set(r, (ruleCounts.get(r) ?? 0) + count);
+        totalFailureInstances += count;
+      }
+    }
+    const commonFailedRules = [...ruleCounts.entries()].map(([rule, count]) => ({
+      rule,
+      frequency: totalFailureInstances > 0 ? count / totalFailureInstances : 0
+    })).filter((r) => r.frequency >= 0.1).sort((a, b) => b.frequency - a.frequency);
+    clusters.push({
+      pattern: describePattern(fp),
+      fingerprint: fp,
+      members,
+      avgFirstTryPassRate,
+      avgAttempts,
+      commonFailedRules
+    });
+  }
+  return clusters.sort((a, b) => b.members.length - a.members.length);
+}
+var NOVELTY_BOOST = 0.05;
+var NOVELTY_PENALTY = 0.03;
+function rerank(candidates, clusters) {
+  const clusterMap = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const member of cluster.members) {
+      clusterMap.set(member.id, cluster);
+    }
+  }
+  const pass1 = candidates.map((c) => {
+    const cluster = clusterMap.get(c.workflow.id);
+    let boost = 0;
+    if (cluster && cluster.avgFirstTryPassRate > 0) {
+      boost = (cluster.avgFirstTryPassRate - 0.5) * 0.1;
+    }
+    if (cluster && cluster.commonFailedRules.length > 0) {
+      boost -= cluster.commonFailedRules.length * 0.02;
+    }
+    return {
+      workflow: c.workflow,
+      score: Math.max(0, Math.min(1, c.score + boost)),
+      cluster
+    };
+  }).sort((a, b) => b.score - a.score);
+  const seenFingerprints = /* @__PURE__ */ new Set();
+  return pass1.map((c) => {
+    const fpKey = c.cluster ? fingerprintKey(c.cluster.fingerprint) : null;
+    let noveltyAdjust = 0;
+    if (fpKey !== null) {
+      if (!seenFingerprints.has(fpKey)) {
+        seenFingerprints.add(fpKey);
+        noveltyAdjust = NOVELTY_BOOST;
+      } else {
+        noveltyAdjust = -NOVELTY_PENALTY;
+      }
+    }
+    return {
+      workflow: c.workflow,
+      score: Math.max(0, Math.min(1, c.score + noveltyAdjust)),
+      ...c.cluster ? { clusterPattern: c.cluster.pattern } : {}
+    };
+  }).sort((a, b) => b.score - a.score);
+}
+
+// src/library/file-library.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+}
+function buildSearchCorpus(w) {
+  const nodeTokens = w.workflow.nodes.map((n) => {
+    const bare = n.type.split(".").pop() ?? "";
+    const spaced = bare.replace(/([A-Z])/g, " $1").trim().toLowerCase();
+    return `${bare} ${spaced}`;
+  });
+  return `${w.description} ${w.workflow.name} ${w.tags.join(" ")} ${nodeTokens.join(" ")}`;
+}
+var _rawSize = parseInt(process.env["KAIROS_LIBRARY_SIZE"] ?? "500", 10);
+var MAX_LIBRARY_SIZE = Number.isFinite(_rawSize) && _rawSize >= 10 ? _rawSize : 500;
+function evictionScore(m) {
+  return (m.deployCount ?? 0) * 3 + (m.timesRetrieved ?? 0) + (m.outcomeStats?.totalUses ?? 0);
+}
+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;
+  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();
+    }
+    return this.initPromise;
+  }
+  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 {
+      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 = [];
+      }
+      await this.scanForOrphansAndCleanup();
+    } 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 });
+    }
+  }
+  async scanForOrphansAndCleanup() {
+    let entries;
+    try {
+      entries = await (0, import_promises.readdir)(this.workflowsDir);
+    } catch {
+      return;
+    }
+    const indexedIds = new Set(this.meta.map((m) => m.id));
+    const orphanIds = [];
+    for (const filename of entries) {
+      if (filename.endsWith(".tmp")) {
+        await (0, import_promises.unlink)((0, import_node_path.join)(this.workflowsDir, filename)).catch(() => {
+        });
+        continue;
+      }
+      if (!filename.endsWith(".json")) continue;
+      const id = filename.slice(0, -5);
+      if (!indexedIds.has(id)) {
+        orphanIds.push(id);
+      }
+    }
+    if (orphanIds.length > 0) {
+      console.warn(`[FileLibrary] Found ${orphanIds.length} orphaned workflow file(s) not in index: ${orphanIds.join(", ")}`);
+    }
+  }
+  /**
+   * 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 {
+      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 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 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 = shells.length;
+    const idf = /* @__PURE__ */ new Map();
+    const idfCeiling = Math.log(docCount + 1) + 1;
+    const allTokens = new Set(queryTokens);
+    for (const token of allTokens) {
+      const docsWithToken = docTokenSets.filter((d) => d.has(token)).length;
+      const rawIdf = Math.log((docCount + 1) / (docsWithToken + 1)) + 1;
+      idf.set(token, rawIdf / idfCeiling);
+    }
+    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);
+    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 existingByN8nId = metadata.n8nWorkflowId ? this.meta.find((m) => m.n8nWorkflowId === metadata.n8nWorkflowId) : void 0;
+    const normalizedDesc = metadata.description.trim().toLowerCase();
+    const existing = existingByN8nId ?? this.meta.find((m) => m.description.trim().toLowerCase() === normalizedDesc);
+    if (existing) {
+      existing.description = metadata.description;
+      existing.workflowName = workflow.name;
+      existing.cachedNodeTypes = workflow.nodes.map((n) => n.type);
+      if (metadata.n8nWorkflowId) existing.n8nWorkflowId = metadata.n8nWorkflowId;
+      if (metadata.generationAttempts != null) {
+        existing.generationAttempts = metadata.generationAttempts;
+      }
+      if (metadata.failurePatterns?.length) {
+        existing.failurePatterns = this.deduplicateFailurePatterns(metadata.failurePatterns);
+      }
+      if (metadata.tags?.length) {
+        existing.tags = [.../* @__PURE__ */ new Set([...existing.tags, ...metadata.tags])];
+      }
+      await this.writeWorkflowFile(existing.id, workflow);
+      await this.persist();
+      return existing.id;
+    }
+    const id = generateUUID();
+    await this.writeWorkflowFile(id, workflow);
+    const failurePatterns = this.deduplicateFailurePatterns(metadata.failurePatterns);
+    const meta = {
+      id,
+      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 } : {},
+      ...metadata.topMatchScore != null ? { topMatchScore: metadata.topMatchScore } : {},
+      ...metadata.generationAttempts != null ? { generationAttempts: metadata.generationAttempts } : {},
+      ...metadata.credentialsNeeded?.length ? { credentialsNeeded: metadata.credentialsNeeded } : {},
+      ...metadata.sourceKind ? { sourceKind: metadata.sourceKind } : {},
+      ...metadata.sourceId ? { sourceId: metadata.sourceId } : {},
+      ...metadata.sourceUrl ? { sourceUrl: metadata.sourceUrl } : {},
+      ...metadata.trustLevel ? { trustLevel: metadata.trustLevel } : {},
+      ...metadata.n8nWorkflowId ? { n8nWorkflowId: metadata.n8nWorkflowId } : {}
+    };
+    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 evictionScore(b) - evictionScore(a);
+      });
+      this.meta = this.meta.slice(0, MAX_LIBRARY_SIZE);
+    }
+    await this.persist();
+    return id;
+  }
+  async recordDeployment(id, n8nWorkflowId) {
+    const m = this.meta.find((m2) => m2.id === id);
+    if (m) {
+      m.deployCount++;
+      m.lastDeployedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (n8nWorkflowId) m.n8nWorkflowId = n8nWorkflowId;
+      await this.persist();
+    }
+  }
+  async recordOutcome(id, outcome) {
+    const m = this.meta.find((m2) => m2.id === id);
+    if (!m) return;
+    if (outcome.mode === "direct") {
+      m.timesUsedAsDirect = (m.timesUsedAsDirect ?? 0) + 1;
+    } else {
+      m.timesUsedAsReference = (m.timesUsedAsReference ?? 0) + 1;
+    }
+    const stats = m.outcomeStats ?? { totalUses: 0, totalAttempts: 0, firstTryPasses: 0, failedRules: {} };
+    stats.totalUses++;
+    stats.totalAttempts += outcome.attempts;
+    if (outcome.firstTryPass) stats.firstTryPasses++;
+    for (const rule of outcome.failedRules) {
+      const key = String(rule);
+      stats.failedRules[key] = (stats.failedRules[key] ?? 0) + 1;
+    }
+    m.outcomeStats = stats;
+    await this.persist();
+  }
+  async drain() {
+    await this.writeQueue;
+  }
+  async get(id) {
+    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 filtered = this.meta;
+    if (filters?.platform) {
+      filtered = filtered.filter((m) => m.platform === filters.platform);
+    }
+    if (filters?.tags && filters.tags.length > 0) {
+      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;
+    const map = /* @__PURE__ */ new Map();
+    for (const fp of patterns) {
+      const existing = map.get(fp.rule);
+      if (existing) {
+        existing.occurrences++;
+      } else {
+        map.set(fp.rule, { rule: fp.rule, message: fp.message, occurrences: 1 });
+      }
+    }
+    return [...map.values()];
+  }
+  // ── Cross-process file locking ────────────────────────────────────────────
+  // Uses O_EXCL (exclusive create) which is atomic on POSIX and Windows NTFS.
+  // Protects the read-modify-write cycle in persist() from concurrent writers
+  // in separate OS processes (e.g. MCP server + CLI running simultaneously).
+  get lockPath() {
+    return (0, import_node_path.join)(this.dir, ".index.lock");
+  }
+  async acquireLock(timeoutMs = 3e3) {
+    const deadline = Date.now() + timeoutMs;
+    let delayMs = 10;
+    while (true) {
+      try {
+        const fh = await (0, import_promises.open)(this.lockPath, "wx");
+        await fh.writeFile(String(process.pid));
+        await fh.close();
+        return async () => {
+          await (0, import_promises.unlink)(this.lockPath).catch(() => {
+          });
+        };
+      } catch {
+        try {
+          const content = await (0, import_promises.readFile)(this.lockPath, "utf-8");
+          const lockPid = parseInt(content.trim(), 10);
+          const fileStat = await (0, import_promises.stat)(this.lockPath);
+          const ageMs = Date.now() - fileStat.mtimeMs;
+          if (ageMs > 1e4) {
+            await (0, import_promises.unlink)(this.lockPath).catch(() => {
+            });
+            continue;
+          }
+          if (!isNaN(lockPid)) {
+            try {
+              process.kill(lockPid, 0);
+            } catch {
+              await (0, import_promises.unlink)(this.lockPath).catch(() => {
+              });
+              continue;
+            }
+          }
+        } catch {
+          continue;
+        }
+        if (Date.now() > deadline) {
+          return async () => {
+          };
+        }
+        await new Promise((r) => setTimeout(r, delayMs));
+        delayMs = Math.min(delayMs * 1.5, 200);
+      }
+    }
+  }
+  /**
+   * Direct write used only during migration (before writeQueue is needed).
+   */
+  async persistNow() {
+    const releaseLock = await this.acquireLock();
+    try {
+      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);
+    } finally {
+      await releaseLock();
+    }
+  }
+  persist() {
+    this.writeQueue = this.writeQueue.then(async () => {
+      const releaseLock = await this.acquireLock();
+      try {
+        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) => evictionScore(b) - evictionScore(a));
+          merged = merged.slice(0, MAX_LIBRARY_SIZE);
+        }
+        const tmpPath = `${indexPath}.tmp`;
+        await (0, import_promises.writeFile)(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
+        await (0, import_promises.rename)(tmpPath, indexPath);
+      } finally {
+        await releaseLock();
+      }
+    });
+    return this.writeQueue;
+  }
+};
+
+// src/validation/registry.ts
+var DEFAULT_REGISTRY = [
+  // Trigger nodes
+  { type: "n8n-nodes-base.manualTrigger", safeTypeVersions: [1], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.scheduleTrigger", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.webhook", safeTypeVersions: [1, 1.1, 2], requiredParams: ["httpMethod", "path"], isTrigger: true },
+  { type: "n8n-nodes-base.formTrigger", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.emailReadImap", safeTypeVersions: [2], requiredParams: [], credentialType: "imap", isTrigger: true },
+  { type: "n8n-nodes-base.errorTrigger", safeTypeVersions: [1], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.executeWorkflowTrigger", safeTypeVersions: [1, 1.1], requiredParams: [], isTrigger: true },
+  { type: "n8n-nodes-base.gmailTrigger", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], credentialType: "gmailOAuth2", isTrigger: true },
+  { type: "n8n-nodes-base.googleDriveTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "googleDriveOAuth2Api", isTrigger: true },
+  { type: "n8n-nodes-base.googleSheetsTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "googleSheetsTriggerOAuth2Api", isTrigger: true },
+  { type: "n8n-nodes-base.slackTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "slackApi", isTrigger: true },
+  { type: "n8n-nodes-base.telegramTrigger", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], credentialType: "telegramApi", isTrigger: true },
+  { type: "n8n-nodes-base.githubTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "githubApi", isTrigger: true },
+  { type: "n8n-nodes-base.stripeTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "stripeApi", isTrigger: true },
+  { type: "n8n-nodes-base.airtableTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "airtableTokenApi", isTrigger: true },
+  { type: "n8n-nodes-base.notionTrigger", safeTypeVersions: [1], requiredParams: [], credentialType: "notionApi", isTrigger: true },
+  { type: "@n8n/n8n-nodes-langchain.chatTrigger", safeTypeVersions: [1, 1.1], requiredParams: [], isTrigger: true },
+  // Core logic nodes
+  { type: "n8n-nodes-base.code", safeTypeVersions: [1, 2], requiredParams: [] },
+  { type: "n8n-nodes-base.httpRequest", safeTypeVersions: [1, 2, 3, 4, 4.1, 4.2], requiredParams: ["url"] },
+  { type: "n8n-nodes-base.set", safeTypeVersions: [1, 2, 3, 3.1, 3.2, 3.3, 3.4], requiredParams: [] },
+  { type: "n8n-nodes-base.if", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [] },
+  { type: "n8n-nodes-base.switch", safeTypeVersions: [1, 2, 3, 3.1, 3.2], requiredParams: [] },
+  { type: "n8n-nodes-base.filter", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [] },
+  { type: "n8n-nodes-base.merge", safeTypeVersions: [1, 2, 2.1, 3], requiredParams: [] },
+  { type: "n8n-nodes-base.splitInBatches", safeTypeVersions: [1, 2, 3], requiredParams: [] },
+  { type: "n8n-nodes-base.wait", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "n8n-nodes-base.executeWorkflow", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [] },
+  { type: "n8n-nodes-base.respondToWebhook", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "n8n-nodes-base.noOp", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.stopAndError", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.splitOut", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.aggregate", safeTypeVersions: [1], requiredParams: [] },
+  { type: "n8n-nodes-base.stickyNote", safeTypeVersions: [1], requiredParams: [] },
+  // Email / messaging
+  { type: "n8n-nodes-base.emailSend", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "smtp" },
+  { type: "n8n-nodes-base.slack", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [], credentialType: "slackOAuth2Api" },
+  { type: "n8n-nodes-base.telegram", safeTypeVersions: [1, 1.1, 1.2], requiredParams: [], credentialType: "telegramApi" },
+  { type: "n8n-nodes-base.discord", safeTypeVersions: [1, 2], requiredParams: [], credentialType: "discordWebhookApi" },
+  // Google
+  { type: "n8n-nodes-base.gmail", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "gmailOAuth2" },
+  { type: "n8n-nodes-base.googleSheets", safeTypeVersions: [1, 2, 3, 4, 4.1, 4.2, 4.3, 4.4, 4.5], requiredParams: [], credentialType: "googleSheetsOAuth2Api" },
+  { type: "n8n-nodes-base.googleDrive", safeTypeVersions: [1, 2, 3], requiredParams: [], credentialType: "googleDriveOAuth2Api" },
+  { type: "n8n-nodes-base.googleCalendar", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [], credentialType: "googleCalendarOAuth2Api" },
+  // Project management / CRM
+  { type: "n8n-nodes-base.notion", safeTypeVersions: [1, 2, 2.1, 2.2], requiredParams: [], credentialType: "notionApi" },
+  { type: "n8n-nodes-base.airtable", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "airtableTokenApi" },
+  { type: "n8n-nodes-base.github", safeTypeVersions: [1, 1.1], requiredParams: [], credentialType: "githubApi" },
+  { type: "n8n-nodes-base.jira", safeTypeVersions: [1], requiredParams: [], credentialType: "jiraSoftwareCloudApi" },
+  { type: "n8n-nodes-base.hubspot", safeTypeVersions: [1, 2, 2.1], requiredParams: [], credentialType: "hubspotOAuth2Api" },
+  // Databases
+  { type: "n8n-nodes-base.postgres", safeTypeVersions: [1, 2, 2.1, 2.2, 2.3, 2.4, 2.5], requiredParams: [], credentialType: "postgres" },
+  { type: "n8n-nodes-base.mySql", safeTypeVersions: [1, 2, 2.1, 2.2, 2.3, 2.4], requiredParams: [], credentialType: "mySql" },
+  { type: "n8n-nodes-base.redis", safeTypeVersions: [1], requiredParams: [], credentialType: "redis" },
+  { type: "n8n-nodes-base.supabase", safeTypeVersions: [1], requiredParams: [], credentialType: "supabaseApi" },
+  // Cloud
+  { type: "n8n-nodes-base.awsS3", safeTypeVersions: [1, 2], requiredParams: [], credentialType: "aws" },
+  // Payment / commerce
+  { type: "n8n-nodes-base.stripe", safeTypeVersions: [1], requiredParams: [], credentialType: "stripeApi" },
+  // AI / LangChain root nodes
+  { type: "@n8n/n8n-nodes-langchain.agent", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.chainLlm", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.chainRetrievalQa", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.openAi", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8], requiredParams: [], credentialType: "openAiApi" },
+  { type: "@n8n/n8n-nodes-langchain.anthropic", safeTypeVersions: [1], requiredParams: [], credentialType: "anthropicApi" },
+  { type: "@n8n/n8n-nodes-langchain.informationExtractor", safeTypeVersions: [1], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.textClassifier", safeTypeVersions: [1], requiredParams: [] },
+  // AI / LangChain sub-nodes (models)
+  { type: "@n8n/n8n-nodes-langchain.lmChatOpenAi", safeTypeVersions: [1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7], requiredParams: [], credentialType: "openAiApi" },
+  { type: "@n8n/n8n-nodes-langchain.lmChatAnthropic", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [], credentialType: "anthropicApi" },
+  { type: "@n8n/n8n-nodes-langchain.lmChatGoogleGemini", safeTypeVersions: [1], requiredParams: [], credentialType: "googlePalmApi" },
+  // AI / LangChain sub-nodes (memory, tools, etc.)
+  { type: "@n8n/n8n-nodes-langchain.memoryBufferWindow", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolWorkflow", safeTypeVersions: [1, 1.1, 1.2, 1.3], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolCode", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolHttpRequest", safeTypeVersions: [1, 1.1], requiredParams: [] },
+  { type: "@n8n/n8n-nodes-langchain.toolCalculator", safeTypeVersions: [1], requiredParams: [] }
+];
+var NodeRegistry = class {
+  byType;
+  constructor(definitions = DEFAULT_REGISTRY) {
+    this.byType = new Map(definitions.map((d) => [d.type, d]));
+  }
+  get(type) {
+    return this.byType.get(type);
+  }
+  isTrigger(type) {
+    return this.byType.get(type)?.isTrigger === true;
+  }
+  isKnown(type) {
+    return this.byType.has(type);
+  }
+  isVersionSafe(type, version) {
+    const def = this.byType.get(type);
+    if (!def) return true;
+    return def.safeTypeVersions.includes(version);
+  }
+  // Returns true when the version is a positive integer greater than the highest
+  // known safe version — indicates a newer release rather than a bad value.
+  isVersionNewer(type, version) {
+    const def = this.byType.get(type);
+    if (!def || def.safeTypeVersions.length === 0) return false;
+    const max = Math.max(...def.safeTypeVersions);
+    return Number.isInteger(version) && version > max;
+  }
+  getRequiredParams(type) {
+    return this.byType.get(type)?.requiredParams ?? [];
+  }
+};
+
+// src/validation/validator.ts
+var AI_CONNECTION_TYPES = [
+  "ai_languageModel",
+  "ai_memory",
+  "ai_tool",
+  "ai_outputParser",
+  "ai_embedding",
+  "ai_document",
+  "ai_textSplitter",
+  "ai_retriever",
+  "ai_vectorStore"
+];
+var TRIGGER_TYPE_PATTERNS = [/trigger/i, /Trigger$/];
+var NODE_TYPE_PATTERN = /^(@[a-z0-9-]+\/[a-z0-9-]+\.|n8n-nodes-[a-z0-9-]+\.)[a-zA-Z][a-zA-Z0-9-]+$/;
+var N8nValidator = class {
+  registry;
+  constructor(registry = new NodeRegistry(DEFAULT_REGISTRY)) {
+    this.registry = registry;
+  }
+  validate(workflow) {
+    const issues = [];
+    this.checkRule1(workflow, issues);
+    this.checkRule2(workflow, issues);
+    this.checkRule3(workflow, issues);
+    this.checkRule4(workflow, issues);
+    this.checkRule5(workflow, issues);
+    this.checkRule6(workflow, issues);
+    this.checkRule7(workflow, issues);
+    this.checkRule8(workflow, issues);
+    this.checkRule9(workflow, issues);
+    this.checkRule10(workflow, issues);
+    this.checkRule11(workflow, issues);
+    this.checkRule12(workflow, issues);
+    this.checkRule13(workflow, issues);
+    this.checkRule14(workflow, issues);
+    this.checkRule15(workflow, issues);
+    this.checkRule16(workflow, issues);
+    this.checkRule17(workflow, issues);
+    this.checkRule18(workflow, issues);
+    this.checkRule19(workflow, issues);
+    this.checkRule20(workflow, issues);
+    this.checkRule21(workflow, issues);
+    this.checkRule22(workflow, issues);
+    this.checkRule23(workflow, issues);
+    this.checkRule24(workflow, issues);
+    this.checkRule25(workflow, issues);
+    this.checkRule26(workflow, issues);
+    this.checkRule27(workflow, issues);
+    this.checkRule28(workflow, issues);
+    this.checkRule29(workflow, issues);
+    this.checkRule30(workflow, issues);
+    this.checkRule31(workflow, issues);
+    this.checkRule32(workflow, issues);
+    this.checkRule33(workflow, issues);
+    this.checkRule34(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, 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, 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) {
+    if (this.registry.isTrigger(node.type)) return true;
+    return TRIGGER_TYPE_PATTERNS.some((p) => p.test(node.type));
+  }
+  // Rule 1: name is a non-empty string
+  checkRule1(w, issues) {
+    if (typeof w.name !== "string" || w.name.trim() === "") {
+      this.err(issues, 1, "Workflow name is required and must be a non-empty string");
+    }
+  }
+  // Rule 2: nodes is an array with at least one element
+  checkRule2(w, issues) {
+    if (!Array.isArray(w.nodes) || w.nodes.length === 0) {
+      this.err(issues, 2, "Workflow must have at least one node");
+    }
+  }
+  // Rule 3: every node has a non-empty id
+  checkRule3(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.id !== "string" || node.id.trim() === "") {
+        this.err(issues, 3, `Node "${node.name ?? "unknown"}" is missing a valid id`, node.id);
+      }
+    }
+  }
+  // Rule 4: node ids are unique
+  checkRule4(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const node of w.nodes) {
+      if (!node.id) continue;
+      if (seen.has(node.id)) {
+        this.err(issues, 4, `Duplicate node id: "${node.id}"`, node.id);
+      }
+      seen.add(node.id);
+    }
+  }
+  // Rule 5: every node has a non-empty type string
+  checkRule5(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string" || node.type.trim() === "") {
+        this.err(issues, 5, `Node "${node.name ?? node.id}" is missing a type`, node.id);
+      }
+    }
+  }
+  // Rule 6: every node has a positive typeVersion number
+  checkRule6(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.typeVersion !== "number" || node.typeVersion <= 0) {
+        this.err(issues, 6, `Node "${node.name}" has invalid typeVersion: ${String(node.typeVersion)}`, node.id);
+      }
+    }
+  }
+  // Rule 7: every node has a valid [x, y] position
+  checkRule7(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      const pos = node.position;
+      if (!Array.isArray(pos) || pos.length !== 2 || typeof pos[0] !== "number" || typeof pos[1] !== "number") {
+        this.err(issues, 7, `Node "${node.name}" has invalid position (must be [x, y])`, node.id);
+      }
+    }
+  }
+  // Rule 8: every node has a non-empty name
+  checkRule8(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.name !== "string" || node.name.trim() === "") {
+        this.err(issues, 8, `Node with id "${node.id}" is missing a name`, node.id);
+      }
+    }
+  }
+  // Rule 9: connections is a plain object
+  checkRule9(w, issues) {
+    if (typeof w.connections !== "object" || w.connections === null || Array.isArray(w.connections)) {
+      this.err(issues, 9, "connections must be a plain object (use {} for single-node workflows)");
+    }
+  }
+  // Rule 10: every connection target node name exists in nodes
+  checkRule10(w, issues) {
+    if (!Array.isArray(w.nodes) || typeof w.connections !== "object" || w.connections === null) return;
+    const nodeNames = new Set(w.nodes.map((n) => n.name));
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
+      if (!nodeNames.has(sourceName)) {
+        this.err(issues, 10, `Connection source "${sourceName}" does not exist in nodes`);
+        continue;
+      }
+      if (typeof outputs !== "object" || outputs === null) continue;
+      for (const portGroup of Object.values(outputs)) {
+        if (!Array.isArray(portGroup)) continue;
+        for (const targets of portGroup) {
+          if (!Array.isArray(targets)) continue;
+          for (const target of targets) {
+            const t = target;
+            if (typeof t?.node === "string" && !nodeNames.has(t.node)) {
+              this.err(issues, 10, `Connection target "${t.node}" does not exist in nodes`);
+            }
+          }
+        }
+      }
+    }
+  }
+  // Rule 11 (WARN): every non-trigger node has at least one incoming connection
+  checkRule11(w, issues) {
+    if (!Array.isArray(w.nodes) || typeof w.connections !== "object" || w.connections === null) return;
+    const reachable = /* @__PURE__ */ new Set();
+    const aiSubNodeSources = /* @__PURE__ */ new Set();
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
+      if (typeof outputs !== "object" || outputs === null) continue;
+      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) {
+            const t = target;
+            if (typeof t?.node === "string") reachable.add(t.node);
+          }
+        }
+      }
+      if (hasAiPort) aiSubNodeSources.add(sourceName);
+    }
+    for (const node of w.nodes) {
+      if (node.type.includes("stickyNote")) continue;
+      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);
+      }
+    }
+  }
+  // Rule 12: forbidden fields absent from workflow root
+  checkRule12(w, issues) {
+    const wObj = w;
+    for (const field of FORBIDDEN_ON_CREATE) {
+      if (field in wObj) {
+        this.err(issues, 12, `Forbidden field "${field}" present in workflow \u2014 remove it before deploying`);
+      }
+    }
+  }
+  // Rule 13: settings, if present, is a plain object
+  checkRule13(w, issues) {
+    if (w.settings !== void 0) {
+      if (typeof w.settings !== "object" || w.settings === null || Array.isArray(w.settings)) {
+        this.err(issues, 13, "workflow.settings must be a plain object");
+      }
+    }
+  }
+  // Rule 14: at least one trigger node is present
+  checkRule14(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const hasTrigger = w.nodes.some((n) => this.isTriggerNode(n));
+    if (!hasTrigger) {
+      this.err(issues, 14, "Workflow must contain at least one trigger node");
+    }
+  }
+  // Rule 15: node type string matches expected format
+  checkRule15(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string") continue;
+      if (!NODE_TYPE_PATTERN.test(node.type)) {
+        this.err(issues, 15, `Node "${node.name}" has malformed type string: "${node.type}"`, node.id);
+      }
+    }
+  }
+  // Rule 16: node names are unique within the workflow
+  checkRule16(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const node of w.nodes) {
+      if (!node.name) continue;
+      if (seen.has(node.name)) {
+        this.err(issues, 16, `Duplicate node name: "${node.name}"`, node.id);
+      }
+      seen.add(node.name);
+    }
+  }
+  // Rule 17: credentials shape — each entry has id and name
+  checkRule17(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (!node.credentials) continue;
+      for (const [credType, credRef] of Object.entries(node.credentials)) {
+        if (typeof credRef !== "object" || credRef === null) {
+          this.err(issues, 17, `Node "${node.name}" credential "${credType}" must be an object with id and name`, node.id);
+          continue;
+        }
+        const ref = credRef;
+        if (typeof ref["id"] !== "string" || ref["id"].trim() === "" || typeof ref["name"] !== "string" || ref["name"].trim() === "") {
+          this.err(issues, 17, `Node "${node.name}" credential "${credType}" must have non-empty string id and name fields`, node.id);
+        }
+      }
+    }
+  }
+  // Rule 18 (ERROR): AI connections must originate from sub-nodes, not the agent/chain root
+  checkRule18(w, issues) {
+    if (typeof w.connections !== "object" || w.connections === null) return;
+    const agentTypes = /* @__PURE__ */ new Set([
+      "@n8n/n8n-nodes-langchain.agent",
+      "@n8n/n8n-nodes-langchain.chainLlm",
+      "@n8n/n8n-nodes-langchain.chainRetrievalQa",
+      "@n8n/n8n-nodes-langchain.chainSummarization"
+    ]);
+    if (!Array.isArray(w.nodes)) return;
+    const nodesByName = new Map(w.nodes.map((n) => [n.name, n]));
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
+      const sourceNode = nodesByName.get(sourceName);
+      if (!sourceNode) continue;
+      if (!agentTypes.has(sourceNode.type)) continue;
+      if (typeof outputs !== "object" || outputs === null) continue;
+      for (const connType of AI_CONNECTION_TYPES) {
+        if (connType in outputs) {
+          this.err(
+            issues,
+            18,
+            `Node "${sourceName}" uses AI connection type "${connType}" as a SOURCE \u2014 AI sub-nodes should be the source, not the agent/chain root`,
+            sourceNode.id
+          );
+        }
+      }
+    }
+  }
+  // Rule 19 (WARN): typeVersion is within known safe range for registered node types.
+  // In lenient mode (KAIROS_REGISTRY_STRICT != 'true'), versions higher than the known
+  // max are allowed — they likely represent newer n8n releases Kairos hasn't catalogued yet.
+  checkRule19(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const strict = process.env["KAIROS_REGISTRY_STRICT"] === "true";
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string" || typeof node.typeVersion !== "number") continue;
+      if (this.registry.isVersionSafe(node.type, node.typeVersion)) continue;
+      if (!strict && this.registry.isVersionNewer(node.type, node.typeVersion)) continue;
+      this.warn(
+        issues,
+        19,
+        `Node "${node.name}" uses typeVersion ${node.typeVersion} for type "${node.type}" which is not in the known safe list`,
+        node.id
+      );
+    }
+  }
+  // Rule 20 (WARN): cycle detection — no node should be reachable from itself
+  // Exempts splitInBatches loops which are an intentional n8n pattern
+  checkRule20(w, issues) {
+    if (!Array.isArray(w.nodes) || typeof w.connections !== "object" || w.connections === null) return;
+    const splitBatchNodes = new Set(
+      w.nodes.filter((n) => n.type.includes("splitInBatches")).map((n) => n.name)
+    );
+    const adj = /* @__PURE__ */ new Map();
+    for (const [sourceName, outputs] of Object.entries(w.connections)) {
+      if (typeof outputs !== "object" || outputs === null) continue;
+      const targets = [];
+      for (const portGroup of Object.values(outputs)) {
+        if (!Array.isArray(portGroup)) continue;
+        for (const conns of portGroup) {
+          if (!Array.isArray(conns)) continue;
+          for (const conn of conns) {
+            const t = conn;
+            if (typeof t?.node === "string") {
+              if (splitBatchNodes.has(t.node)) continue;
+              targets.push(t.node);
+            }
+          }
+        }
+      }
+      adj.set(sourceName, targets);
+    }
+    const WHITE = 0, GRAY = 1, BLACK = 2;
+    const color = /* @__PURE__ */ new Map();
+    for (const node of w.nodes) color.set(node.name, WHITE);
+    const dfs = (name) => {
+      color.set(name, GRAY);
+      for (const neighbor of adj.get(name) ?? []) {
+        const c = color.get(neighbor);
+        if (c === GRAY) return true;
+        if (c === WHITE && dfs(neighbor)) return true;
+      }
+      color.set(name, BLACK);
+      return false;
+    };
+    for (const node of w.nodes) {
+      if (color.get(node.name) === WHITE && dfs(node.name)) {
+        this.warn(issues, 20, "Workflow contains a connection cycle \u2014 this may cause infinite loops");
+        return;
+      }
+    }
+  }
+  // Rule 21 (WARN): webhook with responseMode="responseNode" must have respondToWebhook node
+  checkRule21(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const webhooksNeedingResponse = w.nodes.filter((n) => {
+      if (!n.type.includes("webhook")) return false;
+      const params = n.parameters;
+      return params?.responseMode === "responseNode";
+    });
+    if (webhooksNeedingResponse.length === 0) return;
+    const hasRespondNode = w.nodes.some((n) => n.type.includes("respondToWebhook"));
+    if (!hasRespondNode) {
+      for (const wh of webhooksNeedingResponse) {
+        this.warn(
+          issues,
+          21,
+          `Webhook "${wh.name}" uses responseMode "responseNode" but no respondToWebhook node exists in the workflow`,
+          wh.id
+        );
+      }
+    }
+  }
+  // Rule 22 (WARN): check requiredParams from registry
+  checkRule22(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string") continue;
+      const required = this.registry.getRequiredParams(node.type);
+      if (required.length === 0) continue;
+      const params = node.parameters ?? {};
+      for (const param of required) {
+        const value = params[param];
+        if (value === void 0 || value === null || value === "") {
+          this.warn(
+            issues,
+            22,
+            `Node "${node.name}" (${node.type}) is missing required parameter "${param}"`,
+            node.id
+          );
+        }
+      }
+    }
+  }
+  // Rule 23 (WARN): unknown node types not in registry
+  checkRule23(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (typeof node.type !== "string") continue;
+      if (node.type.includes("stickyNote")) continue;
+      if (!NODE_TYPE_PATTERN.test(node.type)) continue;
+      if (!this.registry.isKnown(node.type)) {
+        this.warn(
+          issues,
+          23,
+          `Node "${node.name}" uses unknown type "${node.type}" \u2014 it may not exist in n8n`,
+          node.id
+        );
+      }
+    }
+  }
+  // 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 27 (WARN): httpRequest URL is a placeholder
+  checkRule27(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    const PLACEHOLDER_RE = [
+      /^https?:\/\/example\.com/i,
+      /your[-_]?(api[-_]?)?url/i,
+      /^https?:\/\/$/,
+      /^<.+>$/,
+      /placeholder/i
+    ];
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.httpRequest") continue;
+      const params = node.parameters;
+      const url = params?.["url"];
+      if (typeof url !== "string" || url.trim() === "") continue;
+      if (PLACEHOLDER_RE.some((re) => re.test(url.trim()))) {
+        this.warn(
+          issues,
+          27,
+          `Node "${node.name}" httpRequest URL appears to be a placeholder: "${url}" \u2014 replace with your actual endpoint`,
+          node.id
+        );
+      }
+    }
+  }
+  // Rule 28 (WARN): code node with empty or comment-only code
+  checkRule28(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.code") continue;
+      const params = node.parameters;
+      const jsCode = typeof params?.["jsCode"] === "string" ? params["jsCode"] : "";
+      const pythonCode = typeof params?.["pythonCode"] === "string" ? params["pythonCode"] : "";
+      const code = jsCode || pythonCode;
+      const stripped = code.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/#[^\n]*/g, "").trim();
+      if (!stripped) {
+        this.warn(issues, 28, `Node "${node.name}" code node has no executable code`, node.id);
+      }
+    }
+  }
+  // Rule 29 (WARN): slack node message operation missing channel
+  checkRule29(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.slack") continue;
+      const params = node.parameters;
+      const resource = params?.["resource"];
+      const operation = params?.["operation"];
+      const isMessageOp = resource === "message" || operation === "sendMessage" || operation === "post";
+      if (!isMessageOp) continue;
+      const channel = params?.["channel"] ?? params?.["channelId"];
+      const rlValue = typeof channel === "object" && channel !== null ? channel["value"] : void 0;
+      const isEmpty = channel === void 0 || channel === null || typeof channel === "string" && channel.trim() === "" || typeof channel === "object" && (!rlValue || typeof rlValue === "string" && rlValue.trim() === "");
+      if (isEmpty) {
+        this.warn(issues, 29, `Node "${node.name}" Slack message has no channel specified`, node.id);
+      }
+    }
+  }
+  // Rule 30 (WARN): gmail node send operation missing recipient
+  checkRule30(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.gmail") continue;
+      const params = node.parameters;
+      const operation = params?.["operation"];
+      if (operation !== "send") continue;
+      const to = params?.["to"] ?? params?.["toList"];
+      const isEmpty = to === void 0 || to === null || typeof to === "string" && to.trim() === "" || Array.isArray(to) && to.length === 0;
+      if (isEmpty) {
+        this.warn(issues, 30, `Node "${node.name}" gmail send has no recipient (to) specified`, node.id);
+      }
+    }
+  }
+  // Rule 31 (WARN): if node with empty conditions
+  checkRule31(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.if") continue;
+      const params = node.parameters;
+      const conditions = params?.["conditions"];
+      if (conditions === void 0 || conditions === null) {
+        this.warn(issues, 31, `Node "${node.name}" if node has no conditions defined`, node.id);
+        continue;
+      }
+      if (typeof conditions === "object" && !Array.isArray(conditions)) {
+        const conds = conditions["conditions"];
+        if (!Array.isArray(conds) || conds.length === 0) {
+          this.warn(issues, 31, `Node "${node.name}" if node conditions array is empty`, node.id);
+        }
+      } else if (Array.isArray(conditions) && conditions.length === 0) {
+        this.warn(issues, 31, `Node "${node.name}" if node conditions array is empty`, node.id);
+      }
+    }
+  }
+  // Rule 32 (WARN): set node with no assignments
+  checkRule32(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.set") continue;
+      const params = node.parameters;
+      const assignmentsObj = params?.["assignments"];
+      const assignmentsArr = assignmentsObj?.["assignments"];
+      const valuesObj = params?.["values"];
+      const hasV1 = valuesObj && Object.values(valuesObj).some((v) => Array.isArray(v) && v.length > 0);
+      const hasV3 = Array.isArray(assignmentsArr) && assignmentsArr.length > 0;
+      if (!hasV1 && !hasV3) {
+        this.warn(
+          issues,
+          32,
+          `Node "${node.name}" set node has no fields defined \u2014 it will pass data through unchanged`,
+          node.id
+        );
+      }
+    }
+  }
+  // Rule 33 (WARN): scheduleTrigger with no schedule rules
+  checkRule33(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.scheduleTrigger") continue;
+      const params = node.parameters;
+      const rule = params?.["rule"];
+      const intervals = rule?.["interval"];
+      if (!Array.isArray(intervals) || intervals.length === 0) {
+        this.warn(issues, 33, `Node "${node.name}" scheduleTrigger has no schedule rules defined`, node.id);
+      }
+    }
+  }
+  // Rule 34 (WARN): webhook path contains spaces, starts with slash, or looks like a full URL
+  checkRule34(w, issues) {
+    if (!Array.isArray(w.nodes)) return;
+    for (const node of w.nodes) {
+      if (node.type !== "n8n-nodes-base.webhook") continue;
+      const params = node.parameters;
+      const path = params?.["path"];
+      if (typeof path !== "string") continue;
+      if (/\s/.test(path)) {
+        this.warn(
+          issues,
+          34,
+          `Node "${node.name}" webhook path contains spaces: "${path}" \u2014 use hyphens or underscores instead`,
+          node.id
+        );
+      } else if (/^https?:\/\//i.test(path)) {
+        this.warn(
+          issues,
+          34,
+          `Node "${node.name}" webhook path looks like a full URL \u2014 it should be a relative path (e.g. "my-hook")`,
+          node.id
+        );
+      } else if (path.startsWith("/")) {
+        this.warn(
+          issues,
+          34,
+          `Node "${node.name}" webhook path starts with "/" \u2014 n8n adds the leading slash automatically`,
+          node.id
+        );
+      }
+    }
+  }
+};
+
+// src/errors/generation-error.ts
+var GenerationError = class extends KairosError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "GenerationError";
+  }
+};
+
+// src/errors/response-parse-error.ts
+var ResponseParseError = class extends KairosError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ResponseParseError";
+  }
+};
+
+// src/errors/validation-error.ts
+var ValidationError = class extends KairosError {
+  constructor(message, issues, attemptMetadata, warnedRules) {
+    super(message);
+    this.issues = issues;
+    this.attemptMetadata = attemptMetadata;
+    this.warnedRules = warnedRules;
+    this.name = "ValidationError";
+  }
+  issues;
+  attemptMetadata;
+  warnedRules;
+};
+
+// src/templates/safety.ts
+var BLOCKED_NODE_TYPES = /* @__PURE__ */ new Set([
+  "n8n-nodes-base.code",
+  "n8n-nodes-base.executeCommand",
+  "n8n-nodes-base.ssh"
+]);
+var REVIEW_NODE_TYPES = /* @__PURE__ */ new Set([
+  "n8n-nodes-base.httpRequest"
+]);
+var SECRET_PATTERNS = [
+  /sk-[a-zA-Z0-9]{20,}/,
+  /ghp_[a-zA-Z0-9]{36}/,
+  /xoxb-[0-9]+-[0-9]+-[a-zA-Z0-9]+/,
+  /AIza[a-zA-Z0-9_-]{35}/,
+  /AKIA[A-Z0-9]{16}/
+];
+var SECRET_PREFIXES = ["sk-", "ghp_", "xoxb-", "AIza", "AKIA"];
+function collectExpressionStrings(obj, out = []) {
+  if (typeof obj === "string") {
+    if (obj.includes("={{")) out.push(obj);
+  } else if (Array.isArray(obj)) {
+    for (const item of obj) collectExpressionStrings(item, out);
+  } else if (obj !== null && typeof obj === "object") {
+    for (const val of Object.values(obj)) {
+      collectExpressionStrings(val, out);
+    }
+  }
+  return out;
+}
+function assessTemplateSafety(workflow) {
+  const reasons = [];
+  let worst = "safe";
+  const escalate = (level, reason) => {
+    reasons.push(reason);
+    if (level === "blocked") worst = "blocked";
+    else if (level === "review" && worst === "safe") worst = "review";
+  };
+  for (const node of workflow.nodes) {
+    if (BLOCKED_NODE_TYPES.has(node.type)) {
+      escalate("blocked", `Contains ${node.type} node "${node.name}"`);
+    }
+    if (REVIEW_NODE_TYPES.has(node.type)) {
+      escalate("review", `Contains ${node.type} node "${node.name}"`);
+    }
+    const paramStr = JSON.stringify(node.parameters);
+    for (const pattern of SECRET_PATTERNS) {
+      if (pattern.test(paramStr)) {
+        escalate("blocked", `Node "${node.name}" parameters contain a hardcoded secret`);
+        break;
+      }
+    }
+    const expressions = collectExpressionStrings(node.parameters);
+    for (const expr of expressions) {
+      for (const prefix of SECRET_PREFIXES) {
+        if (expr.includes(prefix)) {
+          escalate("review", `Node "${node.name}" has an expression containing credential-like prefix "${prefix}"`);
+          break;
+        }
+      }
+    }
+  }
+  return { trustLevel: worst, reasons };
+}
+
+// src/templates/syncer.ts
+var N8N_TEMPLATE_API = "https://api.n8n.io/api/templates";
+var PAGE_SIZE = 50;
+var DELAY_BETWEEN_FETCHES_MS = 200;
+var DEFAULT_SETTINGS = {
+  executionOrder: "v1",
+  saveManualExecutions: true,
+  timezone: "UTC"
+};
+var TemplateSyncer = class {
+  constructor(library, logger) {
+    this.library = library;
+    this.validator = new N8nValidator();
+    this.logger = logger;
+  }
+  library;
+  validator;
+  logger;
+  async sync(options) {
+    const maxTemplates = options?.maxTemplates ?? 500;
+    await this.library.initialize();
+    const existing = await this.library.list();
+    const existingSourceIds = new Set(
+      existing.filter((w) => w.sourceKind === "n8n-template" && w.sourceId).map((w) => w.sourceId)
+    );
+    const progress = {
+      total: 0,
+      processed: 0,
+      saved: 0,
+      skippedPaid: 0,
+      skippedDuplicate: 0,
+      blocked: 0,
+      reviewed: 0
+    };
+    const templateIds = await this.fetchTemplateIds(maxTemplates, progress);
+    for (const id of templateIds) {
+      if (existingSourceIds.has(String(id))) {
+        progress.skippedDuplicate++;
+        progress.processed++;
+        options?.onProgress?.(progress);
+        continue;
+      }
+      try {
+        await this.processTemplate(id, progress);
+      } catch (err) {
+        this.logger.warn(`Failed to process template ${id}`, { err: String(err) });
+      }
+      progress.processed++;
+      options?.onProgress?.(progress);
+      await new Promise((resolve) => setTimeout(resolve, DELAY_BETWEEN_FETCHES_MS));
+    }
+    return progress;
+  }
+  async fetchWithBackoff(url, maxRetries = 3) {
+    let delayMs = DELAY_BETWEEN_FETCHES_MS;
+    let lastResponse;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      lastResponse = await fetch(url);
+      if (lastResponse.status !== 429 && lastResponse.status !== 503) return lastResponse;
+      if (attempt === maxRetries) break;
+      const retryAfterHeader = lastResponse.headers.get("Retry-After");
+      const waitMs = retryAfterHeader ? parseInt(retryAfterHeader, 10) * 1e3 : delayMs * Math.pow(2, attempt);
+      this.logger.warn(`HTTP ${lastResponse.status} from template API, retrying in ${waitMs}ms`, { url, attempt });
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+    }
+    return lastResponse;
+  }
+  async fetchTemplateIds(max, progress) {
+    const ids = [];
+    let page = 1;
+    while (ids.length < max) {
+      const url = `${N8N_TEMPLATE_API}/search?page=${page}&rows=${PAGE_SIZE}`;
+      const response = await this.fetchWithBackoff(url);
+      if (!response.ok) break;
+      const data = await response.json();
+      progress.total = Math.min(data.totalWorkflows, max);
+      for (const template of data.workflows) {
+        if (ids.length >= max) break;
+        if (template.price && template.price > 0) {
+          progress.skippedPaid++;
+          continue;
+        }
+        ids.push(template.id);
+      }
+      if (data.workflows.length < PAGE_SIZE) break;
+      page++;
+      await new Promise((resolve) => setTimeout(resolve, DELAY_BETWEEN_FETCHES_MS));
+    }
+    return ids;
+  }
+  async processTemplate(id, progress) {
+    const url = `${N8N_TEMPLATE_API}/workflows/${id}`;
+    const response = await this.fetchWithBackoff(url);
+    if (!response.ok) return;
+    const data = await response.json();
+    const templateMeta = data.workflow;
+    const rawWorkflow = templateMeta.workflow;
+    if (!rawWorkflow?.nodes?.length) return;
+    const workflow = {
+      name: templateMeta.name,
+      nodes: rawWorkflow.nodes.filter((n) => n.type && n.name),
+      connections: rawWorkflow.connections,
+      settings: rawWorkflow.settings ? { executionOrder: "v1", ...rawWorkflow.settings } : { ...DEFAULT_SETTINGS }
+    };
+    const validation = this.validator.validate(workflow);
+    const validationErrors = validation.issues.filter((i) => i.severity === "error");
+    if (validationErrors.length > 0) {
+      progress.blocked++;
+      this.logger.debug(`Template ${id} blocked: ${validationErrors.length} validation errors`);
+      return;
+    }
+    const safety = assessTemplateSafety(workflow);
+    if (safety.trustLevel === "blocked") {
+      progress.blocked++;
+      this.logger.debug(`Template ${id} blocked: ${safety.reasons.join(", ")}`);
+      return;
+    }
+    if (safety.trustLevel === "review") {
+      progress.reviewed++;
+    }
+    const description = this.cleanDescription(templateMeta.description);
+    const autoTags = Array.from(new Set(
+      workflow.nodes.flatMap((n) => {
+        const bare = n.type.split(".").pop() ?? "";
+        const tags = [bare];
+        if (n.type.includes("Trigger") || n.type.includes("trigger")) tags.push(`trigger:${bare}`);
+        if (n.type.includes("langchain")) tags.push("ai");
+        return tags;
+      })
+    ));
+    const metadata = {
+      description,
+      tags: autoTags,
+      sourceKind: "n8n-template",
+      sourceId: String(id),
+      sourceUrl: `https://n8n.io/workflows/${id}`,
+      trustLevel: safety.trustLevel
+    };
+    await this.library.save(workflow, metadata);
+    progress.saved++;
+    this.logger.debug(`Template ${id} saved: "${templateMeta.name}" (${safety.trustLevel})`);
+  }
+  cleanDescription(raw) {
+    return raw.replace(/#{1,6}\s*/g, "").replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\n{3,}/g, "\n\n").trim().slice(0, 500);
+  }
+};
+
+// src/utils/logger.ts
+var nullLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+
+// src/telemetry/collector.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_os2 = 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_path2.join)((0, import_node_os2.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_promises2.mkdir)(this.dir, { recursive: true }).then(() => {
+      });
+    }
+    await this.dirReady;
+    const filename = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ".jsonl";
+    const filepath = (0, import_node_path2.join)(this.dir, filename);
+    await (0, import_promises2.appendFile)(filepath, JSON.stringify(event) + "\n", "utf-8");
+  }
+};
+
+// src/telemetry/reader.ts
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+
+// src/telemetry/event-reader.ts
+var import_promises3 = require("fs/promises");
+var import_node_fs = 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_promises3.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_fs.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_path4.join)((0, import_node_os3.homedir)(), ".kairos", "telemetry");
+  }
+  async getFailureRates(days = 30) {
+    const now = Date.now();
+    if (this.cache && now - this.cacheTime < 5 * 60 * 1e3) {
+      return this.cache;
+    }
+    const events = await this.readRecentEvents(days);
+    const buildSessions = new Set(
+      events.filter((e) => e.eventType === "build_complete").map((e) => e.runId ?? e.sessionId)
+    );
+    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;
+      const eventKey = event.runId ?? event.sessionId;
+      if (!buildSessions.has(eventKey)) continue;
+      const data = event.data;
+      if (data.validationPassed || !data.issues) continue;
+      for (const issue of data.issues) {
+        const entry = ruleSessions.get(issue.rule) ?? { sessions: /* @__PURE__ */ new Set(), messages: /* @__PURE__ */ new Map() };
+        entry.sessions.add(eventKey);
+        entry.messages.set(issue.message, (entry.messages.get(issue.message) ?? 0) + 1);
+        ruleSessions.set(issue.rule, entry);
+      }
+    }
+    const rates = [];
+    for (const [rule, entry] of ruleSessions) {
+      let topMessage = "";
+      let topCount = 0;
+      for (const [msg, count] of entry.messages) {
+        if (count > topCount) {
+          topMessage = msg;
+          topCount = count;
+        }
+      }
+      rates.push({
+        rule,
+        failureCount: entry.sessions.size,
+        totalBuilds: buildSessions.size,
+        rate: entry.sessions.size / buildSessions.size,
+        commonMessage: topMessage
+      });
+    }
+    rates.sort((a, b) => b.rate - a.rate);
+    this.cache = rates;
+    this.cacheTime = now;
+    return rates;
+  }
+  async readRecentEvents(days) {
+    return readTelemetryEvents(this.dir, days);
+  }
+};
+
+// src/telemetry/pattern-analyzer.ts
+var import_promises4 = require("fs/promises");
+var import_node_path5 = require("path");
+var import_node_os4 = require("os");
+
+// src/validation/rule-metadata.ts
+var VALIDATOR_RULE_IDS = Array.from({ length: 34 }, (_, 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",
+  27: "node_generation",
+  28: "node_generation",
+  29: "node_generation",
+  30: "node_generation",
+  31: "node_generation",
+  32: "node_generation",
+  33: "node_generation",
+  34: "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: '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',
+  27: 'Replace placeholder URLs with your actual API endpoint \u2014 do not use "example.com" or "YOUR_URL" patterns',
+  28: "Add executable code to the code node \u2014 empty or comment-only code nodes do nothing at runtime",
+  29: "Set the channel parameter for Slack message operations (channelId with __rl object, or channel as string)",
+  30: "Set the to parameter for Gmail send operations with at least one recipient email address",
+  31: "Add at least one condition to the if node \u2014 conditions.conditions array must be non-empty",
+  32: "Add field assignments to the set node \u2014 assignments.assignments array must be non-empty for typeVersion 3.x",
+  33: "Add at least one schedule rule to scheduleTrigger \u2014 rule.interval array must have at least one entry",
+  34: 'Webhook path must be a relative path without spaces, leading slashes, or protocol prefixes (e.g. "my-hook")'
+};
+
+// src/telemetry/pattern-analyzer.ts
+var PATTERN_SCHEMA_VERSION = 2;
+var PatternAnalyzer = class _PatternAnalyzer {
+  telemetryDir;
+  outputDir;
+  _cachedEvents = null;
+  _cachedPreviousPatterns = 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() {
+    if (this._cachedPreviousPatterns !== null) return this._cachedPreviousPatterns;
+    try {
+      const raw = await (0, import_promises4.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 ?? [];
+      this._cachedPreviousPatterns = version === PATTERN_SCHEMA_VERSION ? patterns : this.migratePatterns(patterns, version);
+    } catch {
+      this._cachedPreviousPatterns = [];
+    }
+    return this._cachedPreviousPatterns;
+  }
+  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);
+        }
+      }
+    }
+    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_promises4.mkdir)(this.outputDir, { recursive: true });
+    const outputPath = (0, import_node_path5.join)(this.outputDir, "patterns.json");
+    const tmpPath = `${outputPath}.tmp`;
+    await (0, import_promises4.writeFile)(tmpPath, JSON.stringify(analysis, null, 2), "utf-8");
+    await (0, import_promises4.rename)(tmpPath, outputPath);
+    this._cachedPreviousPatterns = null;
+    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_promises4.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_promises4.writeFile)(sessionHistoryTmp, JSON.stringify(sessions, null, 2), "utf-8");
+    await (0, import_promises4.rename)(sessionHistoryTmp, sessionHistoryPath);
+    return analysis;
+  }
+  async getSessions(limit = 20) {
+    try {
+      const raw = await (0, import_promises4.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.runId ?? 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_promises4.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-34)`
+        });
+      }
+    }
+    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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  DEFAULT_REGISTRY,
+  FileLibrary,
+  GenerationError,
+  GuardError,
+  KairosError,
+  N8nApiClient,
+  N8nFieldStripper,
+  N8nProvider,
+  N8nValidator,
+  NodeRegistry,
+  NullLibrary,
+  PatternAnalyzer,
+  ProviderError,
+  ResponseParseError,
+  TelemetryCollector,
+  TelemetryReader,
+  TemplateSyncer,
+  ValidationError,
+  buildSearchCorpus,
+  clusterWorkflows,
+  hybridScore,
+  nullLogger,
+  rerank,
+  tokenize
+});
+//# sourceMappingURL=standalone.cjs.map