@kb-labs/studio-data-client 0.2.0

package/dist/index.js

@@ -0,0 +1,3961 @@
+import axios from 'axios';
+import { ulid } from 'ulid';
+import { z } from 'zod';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { useMemo, useState, useEffect, useRef, useCallback } from 'react';
+
+// src/errors/kb-error.ts
+var KBError = class extends Error {
+  constructor(code, message, status, cause) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.status = status;
+    this.cause = cause;
+    this.name = "KBError";
+  }
+};
+var errorCodes = {
+  NETWORK_ERROR: "NETWORK_ERROR",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  AUTH_ERROR: "AUTH_ERROR",
+  NOT_FOUND: "NOT_FOUND",
+  SERVER_ERROR: "SERVER_ERROR",
+  TIMEOUT_ERROR: "TIMEOUT_ERROR",
+  TIMEOUT: "TIMEOUT",
+  CONFLICT: "CONFLICT",
+  RATE_LIMIT: "RATE_LIMIT",
+  TOOL_ERROR: "TOOL_ERROR"
+};
+
+// src/client/error-mapper.ts
+function isErrorEnvelopeResponse(obj) {
+  return typeof obj === "object" && obj !== null && "ok" in obj && obj.ok === false && "error" in obj && typeof obj.error === "object" && obj.error !== null && "message" in obj.error;
+}
+function mapFetchError(error, response) {
+  if (!response) {
+    if (error instanceof KBError) {
+      return error;
+    }
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+      return new KBError(errorCodes.NETWORK_ERROR, "Network request failed", void 0, error);
+    }
+    return new KBError(errorCodes.NETWORK_ERROR, "Unknown error occurred", void 0, error);
+  }
+  const parsedBody = error;
+  const errorEnvelope = parsedBody && typeof parsedBody === "object" && isErrorEnvelopeResponse(parsedBody) ? parsedBody : null;
+  const httpError = {
+    status: response.status,
+    statusText: response.statusText,
+    data: parsedBody ?? null
+  };
+  const statusCode = response.status;
+  let errorMessage = void 0;
+  if (errorEnvelope !== null) {
+    const envelope = errorEnvelope;
+    errorMessage = envelope.error.message;
+  }
+  if (statusCode === 404) {
+    return new KBError(errorCodes.NOT_FOUND, errorMessage || "Resource not found", 404, httpError);
+  }
+  if (statusCode === 401) {
+    return new KBError(errorCodes.AUTH_ERROR, errorMessage || "Authentication failed", 401, httpError);
+  }
+  if (statusCode === 403) {
+    return new KBError(errorCodes.AUTH_ERROR, errorMessage || "Forbidden", 403, httpError);
+  }
+  if (statusCode === 409) {
+    return new KBError(errorCodes.CONFLICT, errorMessage || "Conflict", 409, httpError);
+  }
+  if (statusCode === 429) {
+    return new KBError(errorCodes.RATE_LIMIT, errorMessage || "Rate limit exceeded", 429, httpError);
+  }
+  if (statusCode >= 500) {
+    return new KBError(errorCodes.SERVER_ERROR, errorMessage || "Server error", statusCode, httpError);
+  }
+  return new KBError(errorCodes.NETWORK_ERROR, errorMessage || httpError.statusText || "Request failed", statusCode, httpError);
+}
+function mapErrorEnvelope(envelope) {
+  const httpError = {
+    status: 400,
+    // Default status
+    statusText: envelope.error.message,
+    data: envelope
+  };
+  const errorCode = envelope.error.code;
+  if (errorCode === "E_NOT_FOUND") {
+    return new KBError(errorCodes.NOT_FOUND, envelope.error.message, 404, httpError);
+  }
+  if (errorCode === "E_UNAUTHORIZED") {
+    return new KBError(errorCodes.AUTH_ERROR, envelope.error.message, 401, httpError);
+  }
+  if (errorCode === "E_FORBIDDEN") {
+    return new KBError(errorCodes.AUTH_ERROR, envelope.error.message, 403, httpError);
+  }
+  if (errorCode === "E_CONFLICT") {
+    return new KBError(errorCodes.CONFLICT, envelope.error.message, 409, httpError);
+  }
+  if (errorCode === "E_RATE_LIMIT") {
+    return new KBError(errorCodes.RATE_LIMIT, envelope.error.message, 429, httpError);
+  }
+  if (errorCode === "E_TIMEOUT") {
+    return new KBError(errorCodes.TIMEOUT, envelope.error.message, 408, httpError);
+  }
+  if (errorCode.startsWith("E_TOOL_")) {
+    return new KBError(errorCodes.TOOL_ERROR, envelope.error.message, 500, httpError);
+  }
+  return new KBError(errorCodes.SERVER_ERROR, envelope.error.message, 500, httpError);
+}
+var HttpClient = class {
+  client;
+  requestInterceptors = [];
+  responseInterceptors = [];
+  errorInterceptors = [];
+  baseUrl;
+  constructor(baseUrl = "", token) {
+    this.baseUrl = baseUrl;
+    this.client = axios.create({
+      baseURL: baseUrl,
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {}
+      }
+    });
+    this.client.interceptors.request.use((config) => {
+      if (!config.headers["X-Request-Id"]) {
+        config.headers["X-Request-Id"] = ulid();
+      }
+      return config;
+    });
+    this.client.interceptors.response.use(
+      (response) => {
+        const data = response.data;
+        if (data && typeof data === "object" && "ok" in data) {
+          if (data.ok === true && "data" in data) {
+            response.data = data.data;
+          } else if (data.ok === false && "error" in data) {
+            const error = mapFetchError(data.error, {
+              status: response.status,
+              statusText: response.statusText
+            });
+            return Promise.reject(error);
+          }
+        }
+        return response;
+      },
+      (error) => {
+        const kbError = mapFetchError(error.response?.data, {
+          status: error.response?.status ?? 500,
+          statusText: error.response?.statusText ?? "Unknown Error"
+        });
+        return Promise.reject(kbError);
+      }
+    );
+  }
+  addRequestInterceptor(interceptor) {
+    this.requestInterceptors.push(interceptor);
+  }
+  addResponseInterceptor(interceptor) {
+    this.responseInterceptors.push(interceptor);
+  }
+  addErrorInterceptor(interceptor) {
+    this.errorInterceptors.push(interceptor);
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  async fetch(path, options = {}) {
+    try {
+      const config = {
+        url: path,
+        ...options
+      };
+      const response = await this.client.request(config);
+      return response.data;
+    } catch (error) {
+      const kbError = error instanceof KBError ? error : mapFetchError(error);
+      throw await this.processError(kbError);
+    }
+  }
+  async processError(error) {
+    let processedError = error;
+    for (const interceptor of this.errorInterceptors) {
+      processedError = await interceptor(processedError);
+    }
+    throw processedError;
+  }
+};
+
+// src/client/envelope-interceptor.ts
+function createEnvelopeInterceptor() {
+  return async (response) => {
+    const contentType = response.headers.get("content-type");
+    if (!contentType?.includes("application/json")) {
+      return response;
+    }
+    if (contentType.includes("text/event-stream")) {
+      return response;
+    }
+    const clonedResponse = response.clone();
+    try {
+      const envelope = await clonedResponse.json();
+      if (envelope && typeof envelope === "object" && "ok" in envelope) {
+        if (envelope.ok === true && "data" in envelope) {
+          const unwrappedData = envelope.data;
+          const headers = new Headers(response.headers);
+          headers.set("Content-Type", "application/json");
+          return new Response(JSON.stringify(unwrappedData), {
+            status: response.status,
+            statusText: response.statusText,
+            headers
+          });
+        } else if (envelope.ok === false && "error" in envelope) {
+          return response;
+        }
+      }
+      return response;
+    } catch (_error) {
+      return response;
+    }
+  };
+}
+function extractEnvelopeMeta(response) {
+  try {
+    const requestId = response.headers.get("X-Request-Id") || void 0;
+    const apiVersion = response.headers.get("X-Schema-Version") || response.headers.get("x-schema-version") || void 0;
+    return {
+      requestId: requestId || void 0,
+      apiVersion: apiVersion || void 0
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/contracts/common.ts
+var SCHEMA_VERSION = "1.0";
+var idSchema = z.string();
+var isoDateSchema = z.string().datetime();
+var packageRefSchema = z.object({
+  name: z.string(),
+  version: z.string().optional(),
+  private: z.boolean().optional(),
+  path: z.string().optional()
+});
+var runRefSchema = z.object({
+  id: idSchema,
+  startedAt: isoDateSchema,
+  endedAt: isoDateSchema.optional(),
+  status: z.enum(["pending", "ok", "warn", "fail"])
+});
+var actionResultSchema = z.object({
+  ok: z.boolean(),
+  message: z.string().optional(),
+  runId: idSchema.optional()
+});
+var auditSummarySchema = z.object({
+  ts: isoDateSchema,
+  totals: z.object({
+    packages: z.number(),
+    ok: z.number(),
+    warn: z.number(),
+    fail: z.number(),
+    durationMs: z.number()
+  }),
+  topFailures: z.array(
+    z.object({
+      pkg: z.string(),
+      checks: z.array(z.enum(["style", "types", "tests", "build", "devlink", "mind"]))
+    })
+  )
+});
+var auditCheckSchema = z.object({
+  id: z.enum(["style", "types", "tests", "build", "devlink", "mind"]),
+  ok: z.boolean(),
+  errors: z.number().optional(),
+  warnings: z.number().optional(),
+  meta: z.unknown().optional()
+});
+var auditPackageReportSchema = z.object({
+  pkg: packageRefSchema,
+  lastRun: runRefSchema,
+  checks: z.array(auditCheckSchema),
+  artifacts: z.object({
+    json: z.string().optional(),
+    md: z.string().optional(),
+    txt: z.string().optional(),
+    html: z.string().optional()
+  })
+});
+var releasePreviewSchema = z.object({
+  range: z.object({
+    from: z.string(),
+    to: z.string()
+  }),
+  packages: z.array(
+    z.object({
+      name: z.string(),
+      prev: z.string(),
+      next: z.string(),
+      bump: z.enum(["major", "minor", "patch", "none"]),
+      breaking: z.number().optional()
+    })
+  ),
+  manifestJson: z.string().optional(),
+  markdown: z.string().optional()
+});
+var healthStatusSchema = z.object({
+  ok: z.boolean(),
+  timestamp: isoDateSchema,
+  sources: z.array(
+    z.object({
+      name: z.string(),
+      ok: z.boolean(),
+      latency: z.number().optional(),
+      error: z.string().optional()
+    })
+  )
+});
+
+// src/sources/http-system-source.ts
+var HttpSystemSource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getHealth() {
+    const snapshot = await this.client.fetch("/observability/health");
+    const degraded = snapshot.status === "degraded" || snapshot.state === "partial_observability";
+    return {
+      ok: snapshot.status === "healthy",
+      timestamp: snapshot.observedAt,
+      sources: snapshot.checks.length > 0 ? snapshot.checks.map((check) => ({
+        name: check.id,
+        ok: check.status === "ok",
+        latency: check.latencyMs,
+        error: check.status === "warn" ? "system_degraded" : check.status === "error" ? check.message ?? "system_error" : void 0
+      })) : [
+        {
+          name: "system",
+          ok: snapshot.status === "healthy",
+          error: degraded ? "system_degraded" : void 0
+        }
+      ],
+      snapshot
+    };
+  }
+  /**
+   * Get ready status
+   */
+  async getReady() {
+    try {
+      return this.client.fetch("/ready");
+    } catch (error) {
+      if (error instanceof KBError && error.status === 503) {
+        const payload = error.cause?.data;
+        if (payload && typeof payload === "object" && "ready" in payload) {
+          return payload;
+        }
+        return {
+          ready: false,
+          reason: "unknown"
+        };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get info
+   */
+  async getInfo() {
+    const response = await this.client.fetch("/info");
+    return response.data;
+  }
+  /**
+   * Get capabilities
+   */
+  async getCapabilities() {
+    const response = await this.client.fetch("/info/capabilities");
+    return response.data;
+  }
+  /**
+   * Get config (redacted)
+   */
+  async getConfig() {
+    const response = await this.client.fetch("/info/config");
+    return response.data;
+  }
+  /**
+   * Get all registered API routes
+   */
+  async getRoutes() {
+    return this.client.fetch("/routes");
+  }
+  /**
+   * Get the base URL of the API
+   */
+  getBaseUrl() {
+    return this.client.getBaseUrl();
+  }
+};
+
+// src/sources/http-workflow-source.ts
+function buildQuery(params) {
+  if (!params || Object.keys(params).length === 0) {
+    return "";
+  }
+  const query = new URLSearchParams();
+  if (params.status) {
+    query.set("status", params.status);
+  }
+  if (typeof params.limit === "number" && !Number.isNaN(params.limit)) {
+    query.set("limit", String(params.limit));
+  }
+  const qs = query.toString();
+  return qs ? `?${qs}` : "";
+}
+var HttpWorkflowSource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listRuns(filters) {
+    const query = buildQuery(filters);
+    return this.client.fetch(`/plugins/workflow/runs${query}`);
+  }
+  async getRun(runId) {
+    try {
+      const response = await this.client.fetch(
+        `/plugins/workflow/runs/${encodeURIComponent(runId)}`
+      );
+      return response.run;
+    } catch (error) {
+      if (error instanceof KBError && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async cancelRun(runId) {
+    await this.client.fetch(
+      `/plugins/workflow/workflows/runs/${encodeURIComponent(runId)}/cancel`,
+      { method: "POST" }
+    );
+    const run = await this.getRun(runId);
+    if (!run) {
+      return { id: runId, status: "cancelled" };
+    }
+    return run;
+  }
+  async runWorkflow(params) {
+    const response = await this.client.fetch(
+      `/plugins/workflow/workflows/${encodeURIComponent(params.spec.name)}/run`,
+      {
+        method: "POST",
+        data: {
+          input: params.metadata
+        }
+      }
+    );
+    return response.run;
+  }
+  async listEvents(runId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.cursor) {
+      params.set("cursor", options.cursor);
+    }
+    if (typeof options.limit === "number" && !Number.isNaN(options.limit)) {
+      params.set("limit", String(options.limit));
+    }
+    const query = params.toString();
+    return this.client.fetch(
+      `/workflows/runs/${runId}/events${query ? `?${query}` : ""}`
+    );
+  }
+  // 🆕 NEW methods for UI
+  async getStats() {
+    return this.client.fetch("/plugins/workflow/stats");
+  }
+  async listWorkflows(filters) {
+    const params = new URLSearchParams();
+    if (typeof filters?.limit === "number" && !Number.isNaN(filters.limit)) {
+      params.set("limit", String(filters.limit));
+    }
+    const query = params.toString();
+    return this.client.fetch(
+      `/plugins/workflow/workflows${query ? `?${query}` : ""}`
+    );
+  }
+  async getWorkflow(workflowId) {
+    try {
+      return await this.client.fetch(
+        `/plugins/workflow/workflows/${encodeURIComponent(workflowId)}`
+      );
+    } catch (error) {
+      if (error instanceof KBError && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async runWorkflowById(workflowId, input) {
+    return this.client.fetch(
+      `/plugins/workflow/workflows/${encodeURIComponent(workflowId)}/run`,
+      {
+        method: "POST",
+        data: { input }
+      }
+    );
+  }
+  async listJobs(filters) {
+    const params = new URLSearchParams();
+    if (filters?.type) {
+      params.set("type", filters.type);
+    }
+    if (filters?.status) {
+      params.set("status", filters.status);
+    }
+    if (typeof filters?.limit === "number" && !Number.isNaN(filters.limit)) {
+      params.set("limit", String(filters.limit));
+    }
+    if (typeof filters?.offset === "number" && !Number.isNaN(filters.offset)) {
+      params.set("offset", String(filters.offset));
+    }
+    const query = params.toString();
+    return this.client.fetch(
+      `/plugins/workflow/jobs${query ? `?${query}` : ""}`
+    );
+  }
+  async getJob(jobId) {
+    try {
+      return await this.client.fetch(
+        `/plugins/workflow/jobs/${encodeURIComponent(jobId)}`
+      );
+    } catch (error) {
+      if (error instanceof KBError && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getJobSteps(jobId) {
+    return this.client.fetch(
+      `/plugins/workflow/jobs/${encodeURIComponent(jobId)}/steps`
+    );
+  }
+  async getJobLogs(jobId, filters) {
+    const params = new URLSearchParams();
+    if (typeof filters?.limit === "number" && !Number.isNaN(filters.limit)) {
+      params.set("limit", String(filters.limit));
+    }
+    if (typeof filters?.offset === "number" && !Number.isNaN(filters.offset)) {
+      params.set("offset", String(filters.offset));
+    }
+    if (filters?.level) {
+      params.set("level", filters.level);
+    }
+    const query = params.toString();
+    return this.client.fetch(
+      `/plugins/workflow/jobs/${encodeURIComponent(jobId)}/logs${query ? `?${query}` : ""}`
+    );
+  }
+  async listCronJobs() {
+    return this.client.fetch("/plugins/workflow/cron");
+  }
+  async getPendingApprovals(runId) {
+    return this.client.fetch(
+      `/plugins/workflow/runs/${encodeURIComponent(runId)}/pending-approvals`
+    );
+  }
+  async resolveApproval(params) {
+    const { runId, ...body } = params;
+    return this.client.fetch(
+      `/plugins/workflow/runs/${encodeURIComponent(runId)}/approve`,
+      {
+        method: "POST",
+        data: body
+      }
+    );
+  }
+  async cancelWorkflowRun(runId) {
+    return this.client.fetch(
+      `/plugins/workflow/workflows/runs/${encodeURIComponent(runId)}/cancel`,
+      { method: "POST" }
+    );
+  }
+  async getWorkflowRuns(workflowId, filters) {
+    const params = new URLSearchParams();
+    if (typeof filters?.limit === "number" && !Number.isNaN(filters.limit)) {
+      params.set("limit", String(filters.limit));
+    }
+    if (typeof filters?.offset === "number" && !Number.isNaN(filters.offset)) {
+      params.set("offset", String(filters.offset));
+    }
+    if (filters?.status) {
+      params.set("status", filters.status);
+    }
+    const query = params.toString();
+    return this.client.fetch(
+      `/plugins/workflow/workflows/${encodeURIComponent(workflowId)}/runs${query ? `?${query}` : ""}`
+    );
+  }
+};
+
+// src/sources/http-cache-source.ts
+var HttpCacheSource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async invalidateCache() {
+    return this.client.fetch("/cache/invalidate", {
+      method: "POST"
+      // No Content-Type header needed for empty body POST
+    });
+  }
+};
+
+// src/sources/prometheus-metrics-parser.ts
+function parseLabels(raw) {
+  if (!raw) {
+    return {};
+  }
+  const labels = {};
+  const pattern = /([a-zA-Z_][a-zA-Z0-9_]*)="((?:\\"|[^"])*)"/g;
+  for (const match of raw.matchAll(pattern)) {
+    const key = match[1];
+    if (!key) {
+      continue;
+    }
+    labels[key] = (match[2] ?? "").replace(/\\"/g, '"');
+  }
+  return labels;
+}
+function parseSamples(text) {
+  const samples = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^([a-zA-Z_:][a-zA-Z0-9_:]*)(?:\{([^}]*)\})?\s+(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)$/);
+    if (!match) {
+      continue;
+    }
+    samples.push({
+      name: match[1],
+      labels: parseLabels(match[2]),
+      value: Number(match[3])
+    });
+  }
+  return samples;
+}
+function sumMetric(samples, metricName) {
+  return samples.filter((sample) => sample.name === metricName).reduce((sum, sample) => sum + sample.value, 0);
+}
+function latestMetric(samples, metricName) {
+  const metric = [...samples].reverse().find((sample) => sample.name === metricName);
+  return metric ? metric.value : null;
+}
+function buildHistogram(samples, bucketMetric) {
+  return samples.filter((sample) => sample.name === bucketMetric && sample.labels.le).map((sample) => ({
+    le: sample.labels.le === "+Inf" ? Number.POSITIVE_INFINITY : Number(sample.labels.le),
+    count: sample.value
+  })).sort((a, b) => a.le - b.le);
+}
+function interpolateQuantile(quantile, histogram) {
+  if (histogram.length === 0) {
+    return 0;
+  }
+  const total = histogram.find((point) => !Number.isFinite(point.le))?.count ?? histogram[histogram.length - 1].count;
+  if (total <= 0) {
+    return 0;
+  }
+  const target = total * quantile;
+  let previousCount = 0;
+  let previousLe = 0;
+  for (const point of histogram) {
+    if (point.count >= target) {
+      if (!Number.isFinite(point.le)) {
+        return previousLe;
+      }
+      const bucketCount = point.count - previousCount;
+      if (bucketCount <= 0) {
+        return point.le;
+      }
+      const progress = (target - previousCount) / bucketCount;
+      return previousLe + (point.le - previousLe) * progress;
+    }
+    previousCount = point.count;
+    if (Number.isFinite(point.le)) {
+      previousLe = point.le;
+    }
+  }
+  return previousLe;
+}
+function buildLatency(samples) {
+  const count = sumMetric(samples, "http_request_duration_ms_count");
+  const total = sumMetric(samples, "http_request_duration_ms_sum");
+  const histogram = buildHistogram(samples, "http_request_duration_ms_bucket");
+  const finiteBuckets = histogram.filter((point) => Number.isFinite(point.le) && point.count > 0);
+  return {
+    average: count > 0 ? total / count : 0,
+    min: finiteBuckets[0]?.le ?? 0,
+    max: finiteBuckets[finiteBuckets.length - 1]?.le ?? 0,
+    p50: interpolateQuantile(0.5, histogram),
+    p95: interpolateQuantile(0.95, histogram),
+    p99: interpolateQuantile(0.99, histogram)
+  };
+}
+function groupByLabel(samples, metricName, label) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const sample of samples) {
+    if (sample.name !== metricName || !sample.labels[label]) {
+      continue;
+    }
+    const key = sample.labels[label];
+    const existing = grouped.get(key) ?? [];
+    existing.push(sample);
+    grouped.set(key, existing);
+  }
+  return grouped;
+}
+function buildPluginMetrics(samples) {
+  const groupedCounts = groupByLabel(samples, "kb_plugin_request_total", "plugin");
+  const durationSums = groupByLabel(samples, "kb_plugin_request_duration_ms_sum", "plugin");
+  const durationCounts = groupByLabel(samples, "kb_plugin_request_duration_ms_count", "plugin");
+  return Array.from(/* @__PURE__ */ new Set([
+    ...groupedCounts.keys(),
+    ...durationSums.keys(),
+    ...durationCounts.keys()
+  ])).map((pluginId) => {
+    const requests = (groupedCounts.get(pluginId) ?? []).reduce((sum, sample) => sum + sample.value, 0);
+    const errors = (groupedCounts.get(pluginId) ?? []).filter((sample) => Number(sample.labels.status_code ?? 0) >= 400).reduce((sum, sample) => sum + sample.value, 0);
+    const totalDuration = (durationSums.get(pluginId) ?? []).reduce((sum, sample) => sum + sample.value, 0);
+    const durationCount = (durationCounts.get(pluginId) ?? []).reduce((sum, sample) => sum + sample.value, 0);
+    return {
+      pluginId,
+      requests,
+      errors,
+      latency: {
+        average: durationCount > 0 ? totalDuration / durationCount : 0,
+        min: 0,
+        max: 0
+      }
+    };
+  });
+}
+function buildTenantMetrics(samples) {
+  const groupedCounts = groupByLabel(samples, "kb_tenant_request_total", "tenant");
+  const errorCounts = groupByLabel(samples, "kb_tenant_request_errors_total", "tenant");
+  const durationSums = groupByLabel(samples, "kb_tenant_request_duration_ms_sum", "tenant");
+  const durationCounts = groupByLabel(samples, "kb_tenant_request_duration_ms_count", "tenant");
+  return Array.from(/* @__PURE__ */ new Set([
+    ...groupedCounts.keys(),
+    ...errorCounts.keys(),
+    ...durationSums.keys(),
+    ...durationCounts.keys()
+  ])).map((tenantId) => {
+    const requests = (groupedCounts.get(tenantId) ?? []).reduce((sum, sample) => sum + sample.value, 0);
+    const errors = (errorCounts.get(tenantId) ?? []).reduce((sum, sample) => sum + sample.value, 0);
+    const totalDuration = (durationSums.get(tenantId) ?? []).reduce((sum, sample) => sum + sample.value, 0);
+    const durationCount = (durationCounts.get(tenantId) ?? []).reduce((sum, sample) => sum + sample.value, 0);
+    return {
+      tenantId,
+      requests,
+      errors,
+      latency: {
+        average: durationCount > 0 ? totalDuration / durationCount : 0
+      }
+    };
+  });
+}
+function buildErrorBreakdown(samples) {
+  const byStatusCode = {};
+  for (const sample of samples) {
+    if (sample.name !== "http_requests_total") {
+      continue;
+    }
+    const statusCode = Number(sample.labels.status_code ?? 0);
+    if (statusCode < 400) {
+      continue;
+    }
+    byStatusCode[statusCode] = (byStatusCode[statusCode] ?? 0) + sample.value;
+  }
+  return {
+    byStatusCode,
+    recent: []
+  };
+}
+function parsePrometheusMetrics(text) {
+  const samples = parseSamples(text);
+  const totalRequests = sumMetric(samples, "http_requests_total");
+  const errors = buildErrorBreakdown(samples);
+  const clientErrors = Object.entries(errors.byStatusCode).filter(([code]) => Number(code) >= 400 && Number(code) < 500).reduce((sum, [, count]) => sum + count, 0);
+  const serverErrors = Object.entries(errors.byStatusCode).filter(([code]) => Number(code) >= 500).reduce((sum, [, count]) => sum + count, 0);
+  const pluginMountTotal = latestMetric(samples, "kb_plugins_mount_total");
+  const pluginMountSucceeded = latestMetric(samples, "kb_plugins_mount_succeeded");
+  const pluginMountFailed = latestMetric(samples, "kb_plugins_mount_failed");
+  const pluginMountElapsedMs = latestMetric(samples, "kb_plugins_mount_elapsed_ms");
+  const uptimeSeconds = latestMetric(samples, "process_uptime_seconds") ?? 0;
+  const redisHealthy = latestMetric(samples, "kb_redis_healthy");
+  const redisTransitions = groupByLabel(samples, "kb_redis_status_transitions_total", "state");
+  return {
+    requests: {
+      total: totalRequests,
+      success: Math.max(0, totalRequests - clientErrors - serverErrors),
+      clientErrors,
+      serverErrors
+    },
+    latency: buildLatency(samples),
+    perPlugin: buildPluginMetrics(samples),
+    perTenant: buildTenantMetrics(samples),
+    errors,
+    timestamps: {
+      startTime: Date.now() - uptimeSeconds * 1e3,
+      lastRequest: null
+    },
+    redis: {
+      updates: sumMetric(samples, "kb_redis_status_updates_total"),
+      healthyTransitions: (redisTransitions.get("healthy") ?? []).reduce((sum, sample) => sum + sample.value, 0),
+      unhealthyTransitions: (redisTransitions.get("unhealthy") ?? []).reduce((sum, sample) => sum + sample.value, 0),
+      lastStatus: redisHealthy === null ? null : {
+        healthy: redisHealthy >= 1,
+        state: redisHealthy >= 1 ? "healthy" : "unhealthy",
+        role: "unknown"
+      }
+    },
+    pluginMounts: pluginMountTotal === null ? null : {
+      total: pluginMountTotal,
+      succeeded: pluginMountSucceeded ?? 0,
+      failed: pluginMountFailed ?? 0,
+      elapsedMs: pluginMountElapsedMs ?? 0
+    },
+    uptime: {
+      seconds: uptimeSeconds,
+      startTime: new Date(Date.now() - uptimeSeconds * 1e3).toISOString(),
+      lastRequest: null
+    }
+  };
+}
+
+// src/sources/http-observability-source.ts
+var HttpObservabilitySource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStateBrokerStats() {
+    try {
+      return await this.client.fetch(
+        "/observability/state-broker"
+      );
+    } catch (error) {
+      throw new KBError(
+        "STATE_BROKER_FETCH_FAILED",
+        "Failed to fetch State Broker stats",
+        500,
+        error
+      );
+    }
+  }
+  async getDevKitHealth() {
+    try {
+      return await this.client.fetch(
+        "/observability/devkit"
+      );
+    } catch (error) {
+      throw new KBError(
+        "DEVKIT_FETCH_FAILED",
+        "Failed to fetch DevKit health",
+        500,
+        error
+      );
+    }
+  }
+  async getPrometheusMetrics() {
+    try {
+      const payload = await this.client.fetch(
+        "/metrics",
+        { responseType: "text" }
+      );
+      return parsePrometheusMetrics(payload);
+    } catch (error) {
+      throw new KBError(
+        "PROMETHEUS_METRICS_FETCH_FAILED",
+        "Failed to fetch Prometheus metrics",
+        500,
+        error
+      );
+    }
+  }
+  subscribeToSystemEvents(onEvent, onError) {
+    const eventSource = new EventSource(`${this.client.getBaseUrl()}/events/registry`);
+    eventSource.addEventListener("registry", (e) => {
+      try {
+        const event = JSON.parse(e.data);
+        onEvent(event);
+      } catch (err) {
+        console.error("Failed to parse registry event:", err);
+      }
+    });
+    eventSource.addEventListener("health", (e) => {
+      try {
+        const event = JSON.parse(e.data);
+        onEvent(event);
+      } catch (err) {
+        console.error("Failed to parse health event:", err);
+      }
+    });
+    eventSource.onerror = () => {
+      onError(new Error("Connection to event stream failed"));
+      eventSource.close();
+    };
+    return () => {
+      eventSource.close();
+    };
+  }
+  async queryLogs(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters.from) {
+        params.append("from", filters.from);
+      }
+      if (filters.to) {
+        params.append("to", filters.to);
+      }
+      if (filters.level) {
+        params.append("level", filters.level);
+      }
+      if (filters.plugin) {
+        params.append("plugin", filters.plugin);
+      }
+      if (filters.executionId) {
+        params.append("executionId", filters.executionId);
+      }
+      if (filters.tenantId) {
+        params.append("tenantId", filters.tenantId);
+      }
+      if (filters.search) {
+        params.append("search", filters.search);
+      }
+      if (filters.limit !== void 0) {
+        params.append("limit", String(filters.limit));
+      }
+      if (filters.offset !== void 0) {
+        params.append("offset", String(filters.offset));
+      }
+      const queryString = params.toString();
+      const url = queryString ? `/logs?${queryString}` : "/logs";
+      return await this.client.fetch(url);
+    } catch (error) {
+      throw new KBError(
+        "LOGS_QUERY_FAILED",
+        "Failed to query logs",
+        500,
+        error
+      );
+    }
+  }
+  subscribeToLogs(onLog, onError, filters) {
+    const params = new URLSearchParams();
+    if (filters?.level) {
+      params.append("level", filters.level);
+    }
+    if (filters?.plugin) {
+      params.append("plugin", filters.plugin);
+    }
+    if (filters?.executionId) {
+      params.append("executionId", filters.executionId);
+    }
+    if (filters?.tenantId) {
+      params.append("tenantId", filters.tenantId);
+    }
+    const queryString = params.toString();
+    const streamBase = this.client.getBaseUrl();
+    const url = queryString ? `${streamBase}/logs/stream?${queryString}` : `${streamBase}/logs/stream`;
+    const eventSource = new EventSource(url);
+    eventSource.addEventListener("log", (e) => {
+      try {
+        const log = JSON.parse(e.data);
+        onLog(log);
+      } catch (err) {
+        console.error("Failed to parse log event:", err);
+      }
+    });
+    eventSource.onerror = () => {
+      onError(new Error("Connection to log stream failed"));
+      eventSource.close();
+    };
+    return () => {
+      eventSource.close();
+    };
+  }
+  async summarizeLogs(request) {
+    try {
+      return await this.client.fetch("/logs/summarize", {
+        method: "POST",
+        data: request
+      });
+    } catch (error) {
+      throw new KBError(
+        "LOG_SUMMARIZATION_FAILED",
+        "Failed to summarize logs",
+        500,
+        error
+      );
+    }
+  }
+  async getLog(id, includeRelated) {
+    try {
+      const params = new URLSearchParams();
+      if (includeRelated) {
+        params.append("includeRelated", "true");
+      }
+      const queryString = params.toString();
+      const url = queryString ? `/logs/${id}?${queryString}` : `/logs/${id}`;
+      return await this.client.fetch(url);
+    } catch (error) {
+      throw new KBError(
+        "LOG_FETCH_FAILED",
+        "Failed to fetch log",
+        500,
+        error
+      );
+    }
+  }
+  async getRelatedLogs(id) {
+    try {
+      return await this.client.fetch(
+        `/logs/${id}/related`
+      );
+    } catch (error) {
+      throw new KBError(
+        "RELATED_LOGS_FETCH_FAILED",
+        "Failed to fetch related logs",
+        500,
+        error
+      );
+    }
+  }
+  async getMetricsHistory(query) {
+    try {
+      const params = new URLSearchParams();
+      params.append("metric", query.metric);
+      params.append("range", query.range);
+      if (query.interval) {
+        params.append("interval", query.interval);
+      }
+      return await this.client.fetch(
+        `/observability/metrics/history?${params.toString()}`
+      );
+    } catch (error) {
+      throw new KBError(
+        "METRICS_HISTORY_FETCH_FAILED",
+        "Failed to fetch metrics history",
+        500,
+        error
+      );
+    }
+  }
+  async getMetricsHeatmap(query) {
+    try {
+      const params = new URLSearchParams();
+      params.append("metric", query.metric);
+      if (query.days) {
+        params.append("days", String(query.days));
+      }
+      return await this.client.fetch(
+        `/observability/metrics/heatmap?${params.toString()}`
+      );
+    } catch (error) {
+      throw new KBError(
+        "METRICS_HEATMAP_FETCH_FAILED",
+        "Failed to fetch metrics heatmap",
+        500,
+        error
+      );
+    }
+  }
+  async queryIncidents(query) {
+    try {
+      const params = new URLSearchParams();
+      if (query?.limit) {
+        params.append("limit", String(query.limit));
+      }
+      if (query?.severity) {
+        const severityList = Array.isArray(query.severity) ? query.severity : [query.severity];
+        params.append("severity", severityList.join(","));
+      }
+      if (query?.type) {
+        const typeList = Array.isArray(query.type) ? query.type : [query.type];
+        params.append("type", typeList.join(","));
+      }
+      if (query?.from) {
+        params.append("from", String(query.from));
+      }
+      if (query?.to) {
+        params.append("to", String(query.to));
+      }
+      if (query?.includeResolved !== void 0) {
+        params.append("includeResolved", String(query.includeResolved));
+      }
+      const queryString = params.toString();
+      const url = queryString ? `/observability/incidents/history?${queryString}` : "/observability/incidents/history";
+      return await this.client.fetch(url);
+    } catch (error) {
+      throw new KBError(
+        "INCIDENTS_QUERY_FAILED",
+        "Failed to query incidents",
+        500,
+        error
+      );
+    }
+  }
+  async createIncident(payload) {
+    try {
+      return await this.client.fetch(
+        "/observability/incidents",
+        {
+          method: "POST",
+          data: payload
+        }
+      );
+    } catch (error) {
+      throw new KBError(
+        "INCIDENT_CREATE_FAILED",
+        "Failed to create incident",
+        500,
+        error
+      );
+    }
+  }
+  async resolveIncident(id, resolutionNotes) {
+    try {
+      return await this.client.fetch(
+        `/observability/incidents/${id}/resolve`,
+        {
+          method: "POST",
+          data: { resolutionNotes }
+        }
+      );
+    } catch (error) {
+      throw new KBError(
+        "INCIDENT_RESOLVE_FAILED",
+        "Failed to resolve incident",
+        500,
+        error
+      );
+    }
+  }
+  async listIncidents(query) {
+    try {
+      const params = buildIncidentQueryParams(query);
+      const url = `/observability/incidents${params ? `?${params}` : ""}`;
+      const response = await this.client.fetch(url);
+      return {
+        ok: true,
+        data: response
+        // HttpClient auto-unwraps envelope
+      };
+    } catch (error) {
+      throw new KBError(
+        "INCIDENTS_LIST_FAILED",
+        "Failed to list incidents",
+        500,
+        error
+      );
+    }
+  }
+  async getIncident(id) {
+    try {
+      const data = await this.client.fetch(`/observability/incidents/${id}`);
+      return {
+        ok: true,
+        data
+      };
+    } catch (error) {
+      throw new KBError(
+        "INCIDENT_FETCH_FAILED",
+        "Failed to fetch incident",
+        500,
+        error
+      );
+    }
+  }
+  async analyzeIncident(id) {
+    try {
+      const data = await this.client.fetch(
+        `/observability/incidents/${id}/analyze`,
+        { method: "POST" }
+      );
+      return {
+        ok: true,
+        data
+      };
+    } catch (error) {
+      throw new KBError(
+        "INCIDENT_ANALYSIS_FAILED",
+        "Failed to analyze incident",
+        500,
+        error
+      );
+    }
+  }
+  async chatWithInsights(question, context) {
+    try {
+      return await this.client.fetch("/observability/insights/chat", {
+        method: "POST",
+        data: { question, context }
+      });
+    } catch (error) {
+      throw new KBError(
+        "INSIGHTS_CHAT_FAILED",
+        "Failed to chat with AI insights",
+        500,
+        error
+      );
+    }
+  }
+};
+function buildIncidentQueryParams(query) {
+  if (!query) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  if (query.limit !== void 0) {
+    params.append("limit", query.limit.toString());
+  }
+  if (query.severity) {
+    const severities = Array.isArray(query.severity) ? query.severity : [query.severity];
+    severities.forEach((s) => params.append("severity", s));
+  }
+  if (query.type) {
+    const types = Array.isArray(query.type) ? query.type : [query.type];
+    types.forEach((t) => params.append("type", t));
+  }
+  if (query.from !== void 0) {
+    params.append("from", query.from.toString());
+  }
+  if (query.to !== void 0) {
+    params.append("to", query.to.toString());
+  }
+  if (query.includeResolved !== void 0) {
+    params.append("includeResolved", query.includeResolved.toString());
+  }
+  return params.toString();
+}
+
+// src/sources/http-analytics-source.ts
+var HttpAnalyticsSource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getEvents(query) {
+    const params = new URLSearchParams();
+    if (query?.type) {
+      if (Array.isArray(query.type)) {
+        query.type.forEach((t) => params.append("type", t));
+      } else {
+        params.set("type", query.type);
+      }
+    }
+    if (query?.source) {
+      params.set("source", query.source);
+    }
+    if (query?.actor) {
+      params.set("actor", query.actor);
+    }
+    if (query?.from) {
+      params.set("from", query.from);
+    }
+    if (query?.to) {
+      params.set("to", query.to);
+    }
+    if (query?.limit) {
+      params.set("limit", String(query.limit));
+    }
+    if (query?.offset) {
+      params.set("offset", String(query.offset));
+    }
+    const path = `/analytics/events${params.toString() ? `?${params}` : ""}`;
+    return this.client.fetch(path);
+  }
+  async getStats() {
+    return this.client.fetch("/analytics/stats");
+  }
+  async getBufferStatus() {
+    try {
+      return this.client.fetch("/analytics/buffer/status");
+    } catch (_error) {
+      return null;
+    }
+  }
+  async getDlqStatus() {
+    try {
+      return this.client.fetch("/analytics/dlq/status");
+    } catch (_error) {
+      return null;
+    }
+  }
+};
+
+// src/sources/http-adapters-source.ts
+var HttpAdaptersSource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Build query string from date range options
+   */
+  buildQueryString(options) {
+    const params = new URLSearchParams();
+    if (options?.from) {
+      params.append("from", options.from);
+    }
+    if (options?.to) {
+      params.append("to", options.to);
+    }
+    if (options?.models) {
+      const modelsArray = Array.isArray(options.models) ? options.models : [options.models];
+      if (modelsArray.length > 0) {
+        params.append("models", modelsArray.join(","));
+      }
+    }
+    if (options?.groupBy) {
+      params.append("groupBy", options.groupBy);
+    }
+    if (options?.breakdownBy) {
+      params.append("breakdownBy", options.breakdownBy);
+    }
+    if (options?.metrics && options.metrics.length > 0) {
+      params.append("metrics", options.metrics.join(","));
+    }
+    const qs = params.toString();
+    return qs ? `?${qs}` : "";
+  }
+  async getLLMUsage(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/llm/usage${query}`);
+  }
+  async getEmbeddingsUsage(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/embeddings/usage${query}`);
+  }
+  async getVectorStoreUsage(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/vectorstore/usage${query}`);
+  }
+  async getCacheUsage(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/cache/usage${query}`);
+  }
+  async getStorageUsage(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/storage/usage${query}`);
+  }
+  async getLLMDailyStats(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/llm/daily-stats${query}`);
+  }
+  async getEmbeddingsDailyStats(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/embeddings/daily-stats${query}`);
+  }
+  async getVectorStoreDailyStats(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/vectorstore/daily-stats${query}`);
+  }
+  async getCacheDailyStats(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/cache/daily-stats${query}`);
+  }
+  async getStorageDailyStats(options) {
+    const query = this.buildQueryString(options);
+    return this.client.fetch(`/adapters/storage/daily-stats${query}`);
+  }
+};
+
+// src/sources/http-platform-source.ts
+var HttpPlatformSource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get platform configuration
+   */
+  async getConfig() {
+    return this.client.fetch("/platform/config");
+  }
+};
+
+// src/sources/http-plugins-source.ts
+var HttpPluginsSource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getPlugins() {
+    return this.client.fetch("/plugins/registry");
+  }
+  async askAboutPlugin(pluginId, request) {
+    return this.client.fetch(`/plugins/${encodeURIComponent(pluginId)}/ask`, {
+      method: "POST",
+      data: request
+    });
+  }
+};
+
+// src/mocks/mock-system-source.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+var MockSystemSource = class {
+  async getHealth() {
+    await delay(150);
+    const snapshot = {
+      schema: "kb.observability/1",
+      contractVersion: "1.0",
+      serviceId: "rest",
+      instanceId: "mock-rest",
+      observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "healthy",
+      uptimeSec: 3600,
+      metricsEndpoint: "/api/v1/metrics",
+      logsSource: "rest",
+      capabilities: ["httpMetrics", "eventLoopMetrics", "operationMetrics", "logCorrelation"],
+      checks: [
+        { id: "registry", status: "ok", message: "Registry snapshot loaded" },
+        { id: "plugin-routes", status: "ok", message: "12 plugin routes mounted" }
+      ],
+      snapshot: {
+        cpuPercent: 6.2,
+        rssBytes: 188743680,
+        heapUsedBytes: 73400320,
+        eventLoopLagMs: 12,
+        activeOperations: 3
+      },
+      topOperations: [
+        { operation: "http.GET /api/v1/health", count: 42, avgDurationMs: 3.1, maxDurationMs: 8.2, errorCount: 0 }
+      ],
+      state: "active"
+    };
+    return {
+      ok: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sources: [
+        { name: "registry", ok: true, latency: 100 },
+        { name: "plugin-routes", ok: true, latency: 120 }
+      ],
+      snapshot
+    };
+  }
+  async getRoutes() {
+    await delay(100);
+    return {
+      schema: "kb.routes/1",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      count: 5,
+      routes: [
+        { method: "GET", url: "/api/v1/health" },
+        { method: "GET", url: "/api/v1/ready" },
+        { method: "GET", url: "/api/v1/plugins" },
+        { method: "GET", url: "/api/v1/plugins/:id" },
+        { method: "POST", url: "/api/v1/workflows/run" }
+      ]
+    };
+  }
+  getBaseUrl() {
+    return "http://localhost:5050/api/v1";
+  }
+};
+function createMockRun(overrides = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: ulid(),
+    name: "demo-workflow",
+    version: "1.0.0",
+    status: "success",
+    createdAt: now,
+    queuedAt: now,
+    startedAt: now,
+    finishedAt: now,
+    trigger: {
+      type: "manual",
+      actor: "mock-user",
+      payload: {}
+    },
+    jobs: [],
+    artifacts: [],
+    metadata: {},
+    ...overrides
+  };
+}
+var MockWorkflowSource = class {
+  runs = [createMockRun()];
+  async listRuns(_filters) {
+    return {
+      runs: this.runs,
+      total: this.runs.length
+    };
+  }
+  async getRun(runId) {
+    return this.runs.find((run) => run.id === runId) ?? null;
+  }
+  async cancelRun(runId) {
+    const run = await this.getRun(runId);
+    if (!run) {
+      throw new Error(`Run ${runId} not found`);
+    }
+    const updated = {
+      ...run,
+      status: "cancelled",
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.runs = this.runs.map((existing) => existing.id === runId ? updated : existing);
+    return updated;
+  }
+  async runWorkflow(params) {
+    const run = createMockRun({
+      id: ulid(),
+      name: params.spec.name,
+      version: params.spec.version,
+      status: "queued",
+      metadata: params.metadata ?? {}
+    });
+    this.runs = [run, ...this.runs];
+    return run;
+  }
+  async listEvents() {
+    return {
+      events: [],
+      cursor: null
+    };
+  }
+  // 🆕 NEW mock methods for UI
+  async getStats() {
+    return {
+      workflows: {
+        total: 5,
+        active: 3,
+        inactive: 2
+      },
+      jobs: {
+        running: 2,
+        pending: 1,
+        completed: 15,
+        failed: 3
+      },
+      crons: {
+        total: 4,
+        enabled: 3,
+        disabled: 1
+      },
+      activeExecutions: [
+        {
+          id: "job-1",
+          type: "workflow:demo",
+          workflowName: "Demo Workflow",
+          status: "running",
+          progress: 45,
+          progressMessage: "Processing step 2 of 4",
+          startedAt: new Date(Date.now() - 3e4).toISOString(),
+          durationMs: 3e4
+        },
+        {
+          id: "job-2",
+          type: "workflow:build",
+          workflowName: "Build Pipeline",
+          status: "running",
+          progress: 75,
+          progressMessage: "Running tests",
+          startedAt: new Date(Date.now() - 12e4).toISOString(),
+          durationMs: 12e4
+        }
+      ],
+      recentActivity: [
+        {
+          id: "job-3",
+          type: "workflow:deploy",
+          workflowName: "Deploy to Production",
+          status: "completed",
+          finishedAt: new Date(Date.now() - 3e5).toISOString(),
+          durationMs: 18e4
+        },
+        {
+          id: "job-4",
+          type: "workflow:test",
+          workflowName: "Integration Tests",
+          status: "failed",
+          finishedAt: new Date(Date.now() - 6e5).toISOString(),
+          durationMs: 45e3,
+          error: "Test suite failed: 3 of 15 tests failed"
+        }
+      ]
+    };
+  }
+  async listWorkflows(_filters) {
+    return {
+      workflows: [
+        {
+          id: "demo-workflow",
+          name: "Demo Workflow",
+          description: "Example workflow for testing",
+          source: "manifest",
+          pluginId: "demo-plugin",
+          status: "active",
+          tags: ["demo", "test"]
+        },
+        {
+          id: "build-pipeline",
+          name: "Build Pipeline",
+          description: "CI/CD build workflow",
+          source: "standalone",
+          status: "active",
+          tags: ["ci", "build"]
+        },
+        {
+          id: "deploy-prod",
+          name: "Deploy to Production",
+          description: "Production deployment workflow",
+          source: "manifest",
+          pluginId: "deploy-plugin",
+          status: "active",
+          tags: ["deploy", "production"]
+        }
+      ]
+    };
+  }
+  async getWorkflow(workflowId) {
+    const workflows = await this.listWorkflows();
+    return workflows.workflows.find((w) => w.id === workflowId) ?? null;
+  }
+  async runWorkflowById(workflowId, _input) {
+    const runId = ulid();
+    console.log(`[MockWorkflowSource] Running workflow ${workflowId}, run ID: ${runId}`);
+    return {
+      runId,
+      status: "pending"
+    };
+  }
+  async listJobs(filters) {
+    const mockJobs = [
+      {
+        id: "job-1",
+        type: "workflow:demo",
+        status: "running",
+        priority: 5,
+        createdAt: new Date(Date.now() - 6e4).toISOString(),
+        startedAt: new Date(Date.now() - 3e4).toISOString(),
+        attempt: 1,
+        maxRetries: 3,
+        progress: 45,
+        progressMessage: "Processing step 2 of 4"
+      },
+      {
+        id: "job-2",
+        type: "workflow:build",
+        status: "completed",
+        priority: 8,
+        createdAt: new Date(Date.now() - 3e5).toISOString(),
+        startedAt: new Date(Date.now() - 28e4).toISOString(),
+        finishedAt: new Date(Date.now() - 12e4).toISOString(),
+        attempt: 1,
+        maxRetries: 3,
+        result: { success: true }
+      },
+      {
+        id: "job-3",
+        type: "workflow:test",
+        status: "failed",
+        priority: 5,
+        createdAt: new Date(Date.now() - 6e5).toISOString(),
+        startedAt: new Date(Date.now() - 58e4).toISOString(),
+        finishedAt: new Date(Date.now() - 535e3).toISOString(),
+        attempt: 3,
+        maxRetries: 3,
+        error: "Test suite failed: 3 of 15 tests failed"
+      }
+    ];
+    let filtered = mockJobs;
+    if (filters?.status) {
+      filtered = filtered.filter((j) => j.status === filters.status);
+    }
+    if (filters?.type) {
+      filtered = filtered.filter((j) => j.type.includes(filters.type));
+    }
+    return { jobs: filtered };
+  }
+  async getJob(jobId) {
+    const jobs = await this.listJobs();
+    return jobs.jobs.find((j) => j.id === jobId) ?? null;
+  }
+  async getJobSteps(jobId) {
+    return {
+      jobId,
+      workflowName: "Demo Workflow",
+      status: "running",
+      steps: [
+        {
+          name: "checkout",
+          handler: "git-checkout",
+          status: "completed",
+          startedAt: new Date(Date.now() - 12e4).toISOString(),
+          finishedAt: new Date(Date.now() - 11e4).toISOString(),
+          durationMs: 1e4
+        },
+        {
+          name: "build",
+          handler: "npm-build",
+          status: "running",
+          progress: 65,
+          startedAt: new Date(Date.now() - 11e4).toISOString()
+        },
+        {
+          name: "test",
+          handler: "npm-test",
+          status: "pending"
+        },
+        {
+          name: "deploy",
+          handler: "k8s-deploy",
+          status: "pending"
+        }
+      ],
+      currentStep: 1
+    };
+  }
+  async getJobLogs(jobId, _filters) {
+    return {
+      jobId,
+      logs: [
+        {
+          timestamp: new Date(Date.now() - 12e4).toISOString(),
+          level: "info",
+          message: "Starting workflow execution",
+          context: { step: "init" }
+        },
+        {
+          timestamp: new Date(Date.now() - 115e3).toISOString(),
+          level: "info",
+          message: "Checking out code from repository",
+          context: { step: "checkout" }
+        },
+        {
+          timestamp: new Date(Date.now() - 11e4).toISOString(),
+          level: "info",
+          message: "Checkout completed successfully",
+          context: { step: "checkout", duration: 1e4 }
+        },
+        {
+          timestamp: new Date(Date.now() - 105e3).toISOString(),
+          level: "info",
+          message: "Installing dependencies",
+          context: { step: "build" }
+        },
+        {
+          timestamp: new Date(Date.now() - 85e3).toISOString(),
+          level: "info",
+          message: "Running build scripts",
+          context: { step: "build" }
+        },
+        {
+          timestamp: new Date(Date.now() - 6e4).toISOString(),
+          level: "warn",
+          message: 'Build warning: Unused variable "foo" in module "bar"',
+          context: { step: "build" }
+        }
+      ],
+      total: 6,
+      hasMore: false
+    };
+  }
+  async listCronJobs() {
+    return {
+      crons: [
+        {
+          id: "daily-backup",
+          schedule: "0 2 * * *",
+          jobType: "backup:database",
+          timezone: "UTC",
+          enabled: true,
+          lastRun: new Date(Date.now() - 864e5).toISOString(),
+          nextRun: new Date(Date.now() + 864e5).toISOString(),
+          pluginId: "backup-plugin"
+        },
+        {
+          id: "hourly-sync",
+          schedule: "0 * * * *",
+          jobType: "sync:data",
+          timezone: "UTC",
+          enabled: true,
+          lastRun: new Date(Date.now() - 36e5).toISOString(),
+          nextRun: new Date(Date.now() + 6e5).toISOString(),
+          pluginId: "sync-plugin"
+        },
+        {
+          id: "weekly-report",
+          schedule: "0 9 * * 1",
+          jobType: "report:generate",
+          timezone: "America/New_York",
+          enabled: false,
+          pluginId: "report-plugin"
+        }
+      ]
+    };
+  }
+  async cancelWorkflowRun(runId) {
+    return { cancelled: true, runId };
+  }
+  async getWorkflowRuns(workflowId, _filters) {
+    return {
+      workflowId,
+      runs: [
+        {
+          id: "run-1",
+          workflowId,
+          status: "completed",
+          trigger: { type: "manual", user: "admin" },
+          startedAt: new Date(Date.now() - 36e5).toISOString(),
+          finishedAt: new Date(Date.now() - 342e4).toISOString(),
+          durationMs: 18e4
+        },
+        {
+          id: "run-2",
+          workflowId,
+          status: "failed",
+          trigger: { type: "cron" },
+          startedAt: new Date(Date.now() - 72e5).toISOString(),
+          finishedAt: new Date(Date.now() - 7155e3).toISOString(),
+          durationMs: 45e3,
+          error: 'Step "deploy" failed: connection timeout'
+        },
+        {
+          id: "run-3",
+          workflowId,
+          status: "completed",
+          trigger: { type: "api", user: "ci-system" },
+          startedAt: new Date(Date.now() - 864e5).toISOString(),
+          finishedAt: new Date(Date.now() - 8622e4).toISOString(),
+          durationMs: 18e4
+        }
+      ],
+      total: 3
+    };
+  }
+};
+
+// src/mocks/mock-cache-source.ts
+var MockCacheSource = class {
+  async invalidateCache() {
+    return {
+      invalidated: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      previousRev: 1,
+      newRev: 2,
+      pluginsDiscovered: 4
+    };
+  }
+};
+
+// src/mocks/mock-observability-source.ts
+function delay2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+var MockObservabilitySource = class {
+  async getStateBrokerStats() {
+    await delay2(150);
+    return {
+      uptime: 36e5,
+      // 1 hour
+      totalEntries: 42,
+      totalSize: 10240,
+      // 10KB
+      hitRate: 0.85,
+      missRate: 0.15,
+      evictions: 5,
+      namespaces: {
+        mind: {
+          entries: 20,
+          hits: 100,
+          misses: 10,
+          size: 5120
+        },
+        workflow: {
+          entries: 15,
+          hits: 80,
+          misses: 5,
+          size: 3072
+        },
+        plugin: {
+          entries: 7,
+          hits: 30,
+          misses: 2,
+          size: 2048
+        }
+      }
+    };
+  }
+  async getDevKitHealth() {
+    await delay2(200);
+    return {
+      healthScore: 68,
+      grade: "D",
+      issues: {
+        duplicateDeps: 30,
+        missingReadmes: 12,
+        typeErrors: 3012,
+        brokenImports: 5,
+        unusedExports: 120
+      },
+      packages: 91,
+      avgTypeCoverage: 91.1
+    };
+  }
+  async getPrometheusMetrics() {
+    await delay2(180);
+    const now = Date.now();
+    const startTime = now - 72e5;
+    return {
+      requests: {
+        total: 1542,
+        success: 1489,
+        clientErrors: 38,
+        serverErrors: 15
+      },
+      latency: {
+        average: 47.3,
+        min: 3.2,
+        max: 892.5,
+        p50: 38.1,
+        p95: 125.7,
+        p99: 287.4
+      },
+      perPlugin: [
+        {
+          pluginId: "workflow",
+          requests: 523,
+          errors: 12,
+          latency: {
+            average: 52.1,
+            min: 5.3,
+            max: 345.2
+          }
+        },
+        {
+          pluginId: "mind",
+          requests: 387,
+          errors: 8,
+          latency: {
+            average: 68.5,
+            min: 12.1,
+            max: 892.5
+          }
+        },
+        {
+          pluginId: "commit",
+          requests: 142,
+          errors: 3,
+          latency: {
+            average: 35.2,
+            min: 8.7,
+            max: 156.3
+          }
+        }
+      ],
+      perTenant: [
+        {
+          tenantId: "default",
+          requests: 1542,
+          errors: 53,
+          latency: {
+            average: 47.3
+          }
+        }
+      ],
+      errors: {
+        byStatusCode: {
+          400: 12,
+          404: 18,
+          422: 8,
+          500: 10,
+          503: 5
+        },
+        recent: [
+          {
+            timestamp: now - 12e4,
+            statusCode: 500,
+            errorCode: "INTERNAL_ERROR",
+            message: "Database connection timeout"
+          },
+          {
+            timestamp: now - 3e5,
+            statusCode: 404,
+            message: "Resource not found"
+          },
+          {
+            timestamp: now - 45e4,
+            statusCode: 422,
+            errorCode: "VALIDATION_ERROR",
+            message: "Invalid request payload"
+          }
+        ]
+      },
+      timestamps: {
+        startTime,
+        lastRequest: now - 2500
+      },
+      redis: {
+        updates: 342,
+        healthyTransitions: 2,
+        unhealthyTransitions: 1,
+        lastStatus: {
+          healthy: true,
+          state: "ready",
+          role: "master"
+        }
+      },
+      pluginMounts: {
+        total: 8,
+        succeeded: 7,
+        failed: 1,
+        elapsedMs: 1247
+      },
+      uptime: {
+        seconds: 7200,
+        startTime: new Date(startTime).toISOString(),
+        lastRequest: new Date(now - 2500).toISOString()
+      }
+    };
+  }
+  async queryLogs(filters) {
+    await delay2(200);
+    const now = Date.now();
+    const oldest = new Date(now - 36e5).toISOString();
+    const newest = new Date(now).toISOString();
+    const mockLogs = Array.from({ length: filters.limit || 20 }, (_, i) => ({
+      time: new Date(now - i * 6e4).toISOString(),
+      level: ["info", "warn", "error"][i % 3],
+      msg: `Mock log entry ${i + 1}`,
+      plugin: filters.plugin || ["rest-api", "workflow", "mind"][i % 3],
+      executionId: filters.executionId || `exec-${i}`,
+      tenantId: filters.tenantId || "default",
+      meta: { mockData: true, index: i }
+    }));
+    return {
+      ok: true,
+      data: {
+        logs: mockLogs,
+        total: 42,
+        filters,
+        bufferStats: {
+          size: mockLogs.length,
+          maxSize: 1e3,
+          oldest,
+          newest
+        }
+      }
+    };
+  }
+  subscribeToSystemEvents(onEvent, _onError) {
+    const interval = setInterval(() => {
+      const now = Date.now();
+      if (Math.random() > 0.5) {
+        onEvent({
+          type: "health",
+          status: "healthy",
+          ts: new Date(now).toISOString(),
+          ready: true,
+          reason: null,
+          registryPartial: false,
+          registryStale: false,
+          registryLoaded: true,
+          pluginMountInProgress: false,
+          pluginRoutesMounted: true,
+          pluginsMounted: 7,
+          pluginsFailed: 1,
+          lastPluginMountTs: new Date(now - 6e4).toISOString(),
+          pluginRoutesLastDurationMs: 1247,
+          redisEnabled: true,
+          redisHealthy: true
+        });
+      } else {
+        onEvent({
+          type: "registry",
+          rev: Math.random().toString(36).substring(7),
+          generatedAt: new Date(now).toISOString(),
+          partial: false,
+          stale: false,
+          expiresAt: new Date(now + 3e5).toISOString(),
+          ttlMs: 3e5,
+          checksum: Math.random().toString(36).substring(2, 15),
+          checksumAlgorithm: "sha256",
+          previousChecksum: null
+        });
+      }
+    }, 3e3);
+    return () => {
+      clearInterval(interval);
+    };
+  }
+  subscribeToLogs(onLog, _onError, filters) {
+    let counter = 0;
+    const interval = setInterval(() => {
+      const now = Date.now();
+      onLog({
+        time: new Date(now).toISOString(),
+        level: ["info", "warn", "error"][counter % 3],
+        msg: `Mock live log ${counter + 1}`,
+        plugin: filters?.plugin || ["rest-api", "workflow", "mind"][counter % 3],
+        executionId: filters?.executionId || `exec-${counter}`,
+        tenantId: filters?.tenantId || "default",
+        meta: { mockData: true, counter }
+      });
+      counter++;
+    }, 2e3);
+    return () => {
+      clearInterval(interval);
+    };
+  }
+  async getLog(_id, includeRelated) {
+    await delay2(200);
+    const now = Date.now();
+    const mockLog = {
+      id: _id,
+      time: new Date(now - 12e4).toISOString(),
+      // 2 minutes ago
+      level: "error",
+      msg: `Mock log entry with id ${_id}`,
+      plugin: "rest-api",
+      executionId: `exec-${_id}`,
+      tenantId: "default",
+      requestId: `req-${_id}`,
+      traceId: `trace-${_id}`,
+      err: {
+        name: "MockError",
+        message: "This is a mock error for demonstration",
+        stack: `MockError: This is a mock error for demonstration
+    at mockFunction (mock.ts:42)
+    at handler (handler.ts:89)
+    at process (process.ts:123)`
+      },
+      meta: { mockData: true }
+    };
+    let related;
+    if (includeRelated) {
+      related = Array.from({ length: 3 }, (_, i) => ({
+        id: `${_id}-related-${i}`,
+        time: new Date(now - (12e4 + i * 1e3)).toISOString(),
+        level: ["info", "debug", "error"][i % 3],
+        msg: `Mock related log ${i + 1}`,
+        plugin: "rest-api",
+        executionId: mockLog.executionId,
+        requestId: mockLog.requestId,
+        traceId: mockLog.traceId,
+        meta: { mockData: true, relatedIndex: i }
+      }));
+    }
+    return { log: mockLog, related };
+  }
+  async getRelatedLogs(_id) {
+    await delay2(150);
+    const now = Date.now();
+    const mockLogs = Array.from({ length: 5 }, (_, i) => ({
+      id: `${_id}-related-${i}`,
+      time: new Date(now - (12e4 + i * 1e3)).toISOString(),
+      level: ["info", "debug", "warn", "error"][i % 4],
+      msg: `Mock related log ${i + 1}`,
+      plugin: "rest-api",
+      executionId: `exec-${_id}`,
+      requestId: `req-${_id}`,
+      traceId: `trace-${_id}`,
+      meta: { mockData: true, relatedIndex: i }
+    }));
+    return {
+      total: mockLogs.length,
+      logs: mockLogs,
+      correlationKeys: {
+        requestId: `req-${_id}`,
+        traceId: `trace-${_id}`,
+        executionId: `exec-${_id}`
+      }
+    };
+  }
+  async summarizeLogs(request) {
+    await delay2(1500);
+    return {
+      ok: true,
+      data: {
+        summary: {
+          question: request.question,
+          timeRange: {
+            from: request.timeRange?.from || null,
+            to: request.timeRange?.to || null
+          },
+          total: 42,
+          stats: {
+            total: 42,
+            byLevel: {
+              error: 3,
+              warn: 5,
+              info: 34
+            },
+            byPlugin: {
+              "rest-api": 20,
+              "workflow": 15,
+              "mind": 7
+            },
+            topErrors: [
+              { message: "Connection timeout", count: 2 },
+              { message: "Invalid parameter", count: 1 }
+            ],
+            timeRange: {
+              from: request.timeRange?.from || null,
+              to: request.timeRange?.to || null
+            }
+          },
+          groups: null
+        },
+        aiSummary: `## Mock AI Summary
+
+Based on the analysis of ${42} log entries:
+
+**Key Findings:**
+- Total of 3 errors and 5 warnings detected
+- Most active component: rest-api (20 logs)
+- Primary issue: Connection timeouts (2 occurrences)
+
+**Timeline:**
+The system has been mostly stable with info-level logs. Two connection timeout errors were observed, likely related to external service availability.
+
+**Recommendations:**
+1. Investigate network connectivity to external services
+2. Consider implementing retry logic with exponential backoff
+3. Monitor timeout patterns over next 24 hours
+
+*Note: This is mock data from MockObservabilitySource*`,
+        message: null
+      }
+    };
+  }
+  async getMetricsHistory(query) {
+    await delay2(100);
+    const now = Date.now();
+    const rangeMs = {
+      "1m": 60 * 1e3,
+      "5m": 5 * 60 * 1e3,
+      "10m": 10 * 60 * 1e3,
+      "30m": 30 * 60 * 1e3,
+      "1h": 60 * 60 * 1e3
+    }[query.range];
+    const intervalMs = query.interval === "1m" ? 60 * 1e3 : query.interval === "5m" ? 5 * 60 * 1e3 : 5e3;
+    const points = [];
+    for (let t = now - rangeMs; t <= now; t += intervalMs) {
+      let value = 0;
+      switch (query.metric) {
+        case "requests":
+          value = 100 + Math.floor(Math.random() * 50);
+          break;
+        case "errors":
+          value = Math.floor(Math.random() * 5);
+          break;
+        case "latency":
+          value = 30 + Math.floor(Math.random() * 20);
+          break;
+        case "uptime":
+          value = (now - t) / 1e3;
+          break;
+      }
+      points.push({ timestamp: t, value });
+    }
+    return points;
+  }
+  async getMetricsHeatmap(query) {
+    await delay2(150);
+    const days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+    const cells = [];
+    for (const day of days) {
+      for (let hour = 0; hour < 24; hour++) {
+        cells.push({ day, hour, value: mockHeatmapValue(query.metric, hour) });
+      }
+    }
+    return cells;
+  }
+  async queryIncidents(query) {
+    await delay2(200);
+    const mockIncidents = [
+      {
+        id: "inc-1",
+        type: "latency_spike",
+        severity: "warning",
+        title: "Elevated API Latency",
+        details: "Average latency increased to 250ms (baseline: 50ms)",
+        rootCause: [
+          {
+            factor: "Database connection pool exhaustion",
+            confidence: 0.85,
+            evidence: "Connection pool utilization at 100%, wait queue growing"
+          },
+          {
+            factor: "Increased query complexity",
+            confidence: 0.6,
+            evidence: "Average query time increased 3x in the last hour"
+          }
+        ],
+        affectedServices: ["rest-api", "workflow-runtime"],
+        timestamp: Date.now() - 2 * 60 * 60 * 1e3,
+        // 2 hours ago
+        resolvedAt: Date.now() - 1 * 60 * 60 * 1e3,
+        // 1 hour ago
+        resolutionNotes: "Increased connection pool size from 10 to 20",
+        metadata: { peakLatency: 350, duration: "45m" }
+      },
+      {
+        id: "inc-2",
+        type: "error_rate",
+        severity: "critical",
+        title: "High Error Rate in Mind Plugin",
+        details: "Error rate spiked to 15% (baseline: <1%)",
+        affectedServices: ["mind-engine"],
+        timestamp: Date.now() - 30 * 60 * 1e3,
+        // 30 minutes ago
+        metadata: { errorCount: 47, requestCount: 310 }
+      },
+      {
+        id: "inc-3",
+        type: "plugin_failure",
+        severity: "warning",
+        title: "Plugin Mount Timeout",
+        details: "workflow plugin took 15s to mount (expected: <3s)",
+        affectedServices: ["workflow-runtime"],
+        timestamp: Date.now() - 10 * 60 * 1e3,
+        // 10 minutes ago
+        resolvedAt: Date.now() - 5 * 60 * 1e3,
+        // 5 minutes ago
+        resolutionNotes: "Plugin restarted successfully"
+      }
+    ];
+    let filtered = [...mockIncidents];
+    if (query?.severity) {
+      const severityList = Array.isArray(query.severity) ? query.severity : [query.severity];
+      filtered = filtered.filter((inc) => severityList.includes(inc.severity));
+    }
+    if (query?.type) {
+      const typeList = Array.isArray(query.type) ? query.type : [query.type];
+      filtered = filtered.filter((inc) => typeList.includes(inc.type));
+    }
+    if (query?.from) {
+      filtered = filtered.filter((inc) => inc.timestamp >= query.from);
+    }
+    if (query?.to) {
+      filtered = filtered.filter((inc) => inc.timestamp <= query.to);
+    }
+    if (!query?.includeResolved) {
+      filtered = filtered.filter((inc) => !inc.resolvedAt);
+    }
+    if (query?.limit) {
+      filtered = filtered.slice(0, query.limit);
+    }
+    return filtered;
+  }
+  async createIncident(payload) {
+    await delay2(150);
+    const incident = {
+      id: `inc-${Date.now()}`,
+      ...payload,
+      timestamp: payload.timestamp || Date.now()
+    };
+    return incident;
+  }
+  async resolveIncident(_id, resolutionNotes) {
+    await delay2(150);
+    const incident = {
+      id: _id,
+      type: "error_rate",
+      severity: "critical",
+      title: "Mock Incident",
+      details: "Mock incident details",
+      timestamp: Date.now() - 60 * 60 * 1e3,
+      resolvedAt: Date.now(),
+      resolutionNotes
+    };
+    return incident;
+  }
+  async listIncidents(query) {
+    await delay2(150);
+    const incidents = await this.queryIncidents(query);
+    const unresolved = incidents.filter((i) => !i.resolvedAt).length;
+    return {
+      ok: true,
+      data: {
+        incidents,
+        summary: {
+          total: incidents.length,
+          unresolved,
+          bySeverity: {
+            critical: incidents.filter((i) => i.severity === "critical").length,
+            warning: incidents.filter((i) => i.severity === "warning").length,
+            info: incidents.filter((i) => i.severity === "info").length
+          },
+          showing: incidents.length
+        }
+      }
+    };
+  }
+  async getIncident(_id) {
+    await delay2(150);
+    const incident = {
+      id: _id,
+      type: "error_rate",
+      severity: "critical",
+      title: "High Error Rate Detected",
+      details: "Error rate exceeded threshold of 10%",
+      timestamp: Date.now() - 60 * 60 * 1e3,
+      affectedServices: ["rest-api", "workflow-engine"],
+      metadata: {
+        errorRate: 15.2,
+        threshold: 10
+      },
+      relatedData: {
+        logs: {
+          errorCount: 42,
+          warnCount: 18,
+          timeRange: [Date.now() - 5 * 60 * 1e3, Date.now()],
+          sampleErrors: [
+            "TypeError: Cannot read property 'name' of undefined",
+            "Error: Failed to connect to database",
+            "Error: Timeout exceeded for operation"
+          ]
+        },
+        metrics: {
+          before: {
+            errorRate: 2.1,
+            avgLatency: 45,
+            totalRequests: 1e3
+          },
+          during: {
+            errorRate: 15.2,
+            avgLatency: 120,
+            totalRequests: 500,
+            totalErrors: 76
+          }
+        },
+        timeline: [
+          {
+            timestamp: Date.now(),
+            event: "Incident detected: error_rate",
+            source: "detector"
+          },
+          {
+            timestamp: Date.now() - 2 * 60 * 1e3,
+            event: "Error: Failed to connect to database",
+            source: "logs"
+          },
+          {
+            timestamp: Date.now() - 3 * 60 * 1e3,
+            event: "Error: Timeout exceeded for operation",
+            source: "logs"
+          }
+        ]
+      }
+    };
+    return {
+      ok: true,
+      data: incident
+    };
+  }
+  async analyzeIncident(_id) {
+    await delay2(800);
+    return {
+      ok: true,
+      data: {
+        summary: "High error rate detected due to database connection issues and timeout problems. System experienced 15.2% error rate, significantly above the 2.1% baseline.",
+        rootCauses: [
+          {
+            factor: "Database connection pool exhaustion",
+            confidence: 0.85,
+            evidence: 'Multiple "Failed to connect to database" errors in logs. Error rate correlation with database connection attempts.'
+          },
+          {
+            factor: "Increased request timeout frequency",
+            confidence: 0.72,
+            evidence: "Timeout errors increased from 0% to 8% during incident window. Latency jumped from 45ms to 120ms."
+          },
+          {
+            factor: "Potential memory leak in error handler",
+            confidence: 0.45,
+            evidence: "TypeError suggests undefined object access, possibly due to improper error handling initialization."
+          }
+        ],
+        patterns: [
+          "Error rate spike correlates with increased latency (45ms \u2192 120ms)",
+          "Database connection errors preceded timeout errors by ~1 minute",
+          "Error rate increased 7x above baseline during incident"
+        ],
+        recommendations: [
+          "Increase database connection pool size and implement connection retry logic with exponential backoff",
+          "Add circuit breaker pattern to prevent cascading failures when database is unavailable",
+          "Review error handling code for undefined object access, especially in database connection error paths",
+          "Implement request timeout monitoring and alerting at 75% of threshold",
+          "Consider adding database health check endpoint to proactively detect connection issues"
+        ],
+        analyzedAt: Date.now(),
+        cached: false
+      }
+    };
+  }
+  async chatWithInsights(question, context) {
+    await delay2(500);
+    return {
+      answer: `Based on the current system metrics, here's my analysis of "${question}": The system is performing well with average latency of 45ms and 99.2% success rate. No critical issues detected.`,
+      context: [
+        "Current metrics: 1,234 requests in the last hour",
+        "Average latency: 45ms",
+        "Error rate: 0.8%",
+        context?.includeIncidents ? "2 active incidents" : void 0
+      ].filter(Boolean),
+      usage: {
+        promptTokens: 150,
+        completionTokens: 80,
+        totalTokens: 230
+      }
+    };
+  }
+};
+function mockHeatmapValue(metric, hour) {
+  const isBusinessHour = hour >= 9 && hour <= 17;
+  if (metric === "latency") {
+    return 30 + Math.floor(Math.random() * 40) + (isBusinessHour ? 10 : 0);
+  }
+  if (metric === "errors") {
+    return Math.floor(Math.random() * 10);
+  }
+  if (metric === "requests") {
+    return 50 + Math.floor(Math.random() * 100) + (isBusinessHour ? 50 : 0);
+  }
+  return 0;
+}
+
+// src/mocks/mock-analytics-source.ts
+function delay3(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+var MockAnalyticsSource = class {
+  mockEvents;
+  constructor() {
+    this.mockEvents = this.generateMockEvents();
+  }
+  generateMockEvents() {
+    const now = Date.now();
+    const events = [];
+    const eventTypes = [
+      "mind.query.started",
+      "mind.query.completed",
+      "workflow.run.started",
+      "workflow.run.completed",
+      "commit.generated",
+      "plugin.mounted"
+    ];
+    const sources = ["mind", "workflow", "commit", "core"];
+    const actors = ["user", "agent", "ci"];
+    for (let i = 0; i < 100; i++) {
+      const ts = new Date(now - i * 6e4).toISOString();
+      const type = eventTypes[Math.floor(Math.random() * eventTypes.length)];
+      const source = sources[Math.floor(Math.random() * sources.length)];
+      const actorType = actors[Math.floor(Math.random() * actors.length)];
+      events.push({
+        id: `mock-event-${i}`,
+        schema: "kb.v1",
+        type,
+        ts,
+        ingestTs: ts,
+        source: {
+          product: source,
+          version: "1.0.0"
+        },
+        runId: `run-${Math.floor(i / 5)}`,
+        // Group every 5 events
+        actor: {
+          type: actorType,
+          id: `${actorType}-${Math.floor(Math.random() * 10)}`,
+          name: `Mock ${actorType}`
+        },
+        ctx: {
+          workspace: "/mock/workspace",
+          branch: "main"
+        },
+        payload: {
+          duration: Math.random() * 1e3,
+          success: Math.random() > 0.1
+        }
+      });
+    }
+    return events;
+  }
+  async getEvents(query) {
+    await delay3(150);
+    let filtered = [...this.mockEvents];
+    if (query?.type) {
+      const types = Array.isArray(query.type) ? query.type : [query.type];
+      filtered = filtered.filter((e) => types.includes(e.type));
+    }
+    if (query?.source) {
+      filtered = filtered.filter((e) => e.source.product === query.source);
+    }
+    if (query?.actor) {
+      filtered = filtered.filter((e) => e.actor?.type === query.actor);
+    }
+    const limit = query?.limit || 100;
+    const offset = query?.offset || 0;
+    const paginated = filtered.slice(offset, offset + limit);
+    return {
+      events: paginated,
+      total: filtered.length,
+      hasMore: offset + limit < filtered.length
+    };
+  }
+  async getStats() {
+    await delay3(180);
+    const byType = {};
+    const bySource = {};
+    const byActor = {};
+    this.mockEvents.forEach((event) => {
+      byType[event.type] = (byType[event.type] || 0) + 1;
+      bySource[event.source.product] = (bySource[event.source.product] || 0) + 1;
+      if (event.actor) {
+        byActor[event.actor.type] = (byActor[event.actor.type] || 0) + 1;
+      }
+    });
+    const timestamps = this.mockEvents.map((e) => new Date(e.ts).getTime());
+    const oldestTs = Math.min(...timestamps);
+    const newestTs = Math.max(...timestamps);
+    return {
+      totalEvents: this.mockEvents.length,
+      byType,
+      bySource,
+      byActor,
+      timeRange: {
+        from: new Date(oldestTs).toISOString(),
+        to: new Date(newestTs).toISOString()
+      }
+    };
+  }
+  async getBufferStatus() {
+    await delay3(100);
+    const timestamps = this.mockEvents.map((e) => new Date(e.ts).getTime());
+    return {
+      segments: 3,
+      totalSizeBytes: 524288,
+      // 512 KB
+      oldestEventTs: new Date(Math.min(...timestamps)).toISOString(),
+      newestEventTs: new Date(Math.max(...timestamps)).toISOString()
+    };
+  }
+  async getDlqStatus() {
+    await delay3(100);
+    return {
+      failedEvents: 2,
+      oldestFailureTs: new Date(Date.now() - 36e5).toISOString()
+      // 1 hour ago
+    };
+  }
+};
+
+// src/mocks/mock-adapters-source.ts
+var MockAdaptersSource = class {
+  async getLLMUsage(_options) {
+    return {
+      totalRequests: 1247,
+      totalTokens: 3456789,
+      totalCost: 12.45,
+      totalCacheReadTokens: 0,
+      totalBillableTokens: 3456789,
+      totalCacheSavingsUsd: 0,
+      byModel: {
+        "gpt-4": {
+          requests: 234,
+          promptTokens: 45678,
+          completionTokens: 23456,
+          totalTokens: 69134,
+          cost: 4.15,
+          costPer1KTokens: 0.06,
+          tokensPerRequest: 295,
+          errorRate: 0.5,
+          avgDurationMs: 2345,
+          cacheReadTokens: 0,
+          billableTokens: 69134,
+          cacheSavingsUsd: 0
+        },
+        "gpt-3.5-turbo": {
+          requests: 789,
+          promptTokens: 234567,
+          completionTokens: 123456,
+          totalTokens: 358023,
+          cost: 0.54,
+          costPer1KTokens: 15e-4,
+          tokensPerRequest: 454,
+          errorRate: 0,
+          avgDurationMs: 876,
+          cacheReadTokens: 0,
+          billableTokens: 358023,
+          cacheSavingsUsd: 0
+        },
+        "claude-3-sonnet": {
+          requests: 224,
+          promptTokens: 567890,
+          completionTokens: 234567,
+          totalTokens: 802457,
+          cost: 7.76,
+          costPer1KTokens: 97e-4,
+          tokensPerRequest: 3582,
+          errorRate: 1.2,
+          avgDurationMs: 1567,
+          cacheReadTokens: 0,
+          billableTokens: 802457,
+          cacheSavingsUsd: 0
+        }
+      },
+      errors: 12,
+      timeRange: {
+        from: new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString(),
+        to: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  async getEmbeddingsUsage(_options) {
+    return {
+      totalRequests: 3456,
+      totalTextLength: 1234567,
+      totalCost: 2.47,
+      errors: 8,
+      avgDurationMs: 234,
+      batchRequests: 456,
+      singleRequests: 3e3,
+      avgBatchSize: 15.3
+    };
+  }
+  async getVectorStoreUsage(_options) {
+    return {
+      searchQueries: 2345,
+      upsertOperations: 567,
+      deleteOperations: 89,
+      avgSearchDuration: 45.6,
+      avgSearchScore: 0.87,
+      avgResultsCount: 12.4,
+      totalVectorsUpserted: 45678,
+      totalVectorsDeleted: 1234
+    };
+  }
+  async getCacheUsage(_options) {
+    return {
+      totalGets: 15678,
+      hits: 13456,
+      misses: 2222,
+      hitRate: 85.8,
+      sets: 3456,
+      avgGetDuration: 2.3,
+      avgSetDuration: 5.7
+    };
+  }
+  async getStorageUsage(_options) {
+    return {
+      readOperations: 8765,
+      writeOperations: 2345,
+      deleteOperations: 234,
+      totalBytesRead: 123456789,
+      totalBytesWritten: 45678901,
+      avgReadDuration: 12.4,
+      avgWriteDuration: 34.5
+    };
+  }
+  async getLLMDailyStats(_options) {
+    return this.generateMockDailyStats({
+      totalTokens: [1e4, 6e4],
+      totalCost: [1, 6],
+      avgDurationMs: [500, 2500]
+    });
+  }
+  async getEmbeddingsDailyStats(_options) {
+    return this.generateMockDailyStats({
+      totalTokens: [5e3, 3e4],
+      totalCost: [0.1, 0.5],
+      avgDurationMs: [100, 500]
+    });
+  }
+  async getVectorStoreDailyStats(_options) {
+    return this.generateMockDailyStats({
+      totalSearches: [100, 500],
+      totalUpserts: [50, 200],
+      totalDeletes: [10, 50],
+      avgDurationMs: [30, 150]
+    });
+  }
+  async getCacheDailyStats(_options) {
+    return this.generateMockDailyStats({
+      totalHits: [500, 2e3],
+      totalMisses: [100, 500],
+      totalSets: [200, 800],
+      hitRate: [70, 95]
+    });
+  }
+  async getStorageDailyStats(_options) {
+    return this.generateMockDailyStats({
+      totalBytesRead: [1e6, 1e7],
+      totalBytesWritten: [5e5, 5e6],
+      avgDurationMs: [10, 50]
+    });
+  }
+  /**
+   * Helper to generate mock daily stats
+   */
+  generateMockDailyStats(metricsRanges) {
+    const days = 7;
+    const stats = [];
+    const now = /* @__PURE__ */ new Date();
+    for (let i = days - 1; i >= 0; i--) {
+      const date = new Date(now);
+      date.setDate(date.getDate() - i);
+      const dateStr = date.toISOString().split("T")[0];
+      const metrics = {};
+      for (const [key, [min, max]] of Object.entries(metricsRanges)) {
+        metrics[key] = Math.floor(Math.random() * (max - min)) + min;
+      }
+      stats.push({
+        date: dateStr,
+        count: Math.floor(Math.random() * 100) + 50,
+        // 50-150 requests
+        metrics
+      });
+    }
+    return stats;
+  }
+};
+
+// src/mocks/mock-platform-source.ts
+var MockPlatformSource = class {
+  async getConfig() {
+    return {
+      schema: "kb.platform.config/1",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      adapters: {
+        // Multi-adapter example: array of providers for LLM
+        llm: ["@kb-labs/adapters-openai", "@kb-labs/adapters-vibeproxy"],
+        embeddings: "@kb-labs/adapters-openai/embeddings",
+        storage: "@kb-labs/adapters-fs",
+        logger: "@kb-labs/adapters-pino",
+        analytics: "@kb-labs/adapters-analytics-file",
+        vectorStore: "@kb-labs/adapters-qdrant",
+        cache: "@kb-labs/adapters-redis"
+      },
+      adapterOptions: {
+        llm: {
+          defaultModel: "gpt-4o-mini"
+        },
+        vectorStore: {
+          url: "http://localhost:6333"
+        },
+        cache: {
+          url: "redis://localhost:6379"
+        }
+      },
+      execution: {
+        mode: "in-process"
+      },
+      redacted: []
+    };
+  }
+};
+
+// src/mocks/mock-plugins-source.ts
+var mockManifests = {
+  manifests: [
+    {
+      pluginId: "@kb-labs/mind-plugin",
+      source: {
+        kind: "workspace",
+        path: "/workspace/kb-labs-mind/packages/mind-plugin"
+      },
+      pluginRoot: "/workspace/kb-labs-mind/packages/mind-plugin",
+      discoveredAt: new Date(Date.now() - 36e5).toISOString(),
+      // 1 hour ago
+      buildTimestamp: new Date(Date.now() - 72e5).toISOString(),
+      // 2 hours ago
+      manifest: {
+        schema: "kb.plugin/3",
+        id: "@kb-labs/mind-plugin",
+        version: "0.1.0",
+        display: {
+          name: "Mind RAG Plugin",
+          description: "Semantic code search and RAG system",
+          author: "KB Labs",
+          icon: "\u{1F9E0}",
+          tags: ["search", "ai", "rag"]
+        },
+        permissions: {
+          fs: { mode: "read", allow: [".kb/**", "src/**"] },
+          net: { allowHosts: ["api.openai.com"] }
+        },
+        platform: {
+          requires: ["vectorStore", "embeddings", "cache"]
+        },
+        cli: {
+          commands: [
+            {
+              id: "rag-query",
+              group: "mind",
+              describe: "Query the RAG index",
+              handler: "./dist/commands/rag-query.js",
+              flags: [
+                { name: "text", type: "string", required: true, description: "Query text" },
+                { name: "agent", type: "boolean", description: "Use agent mode" }
+              ]
+            },
+            {
+              id: "rag-index",
+              group: "mind",
+              describe: "Build RAG index",
+              handler: "./dist/commands/rag-index.js",
+              flags: [
+                { name: "scope", type: "string", default: "default", description: "Index scope" }
+              ]
+            }
+          ]
+        },
+        rest: {
+          basePath: "/v1/plugins/mind",
+          routes: [
+            {
+              method: "POST",
+              path: "/search",
+              description: "Semantic code search",
+              handler: "./dist/rest/search.js",
+              timeoutMs: 3e4,
+              input: { zod: "./schemas/search-input.ts#SearchInputSchema" },
+              output: { zod: "./schemas/search-output.ts#SearchOutputSchema" }
+            }
+          ]
+        }
+      }
+    },
+    {
+      pluginId: "@kb-labs/workflow-plugin",
+      source: {
+        kind: "workspace",
+        path: "/workspace/kb-labs-workflow/packages/workflow-plugin"
+      },
+      pluginRoot: "/workspace/kb-labs-workflow/packages/workflow-plugin",
+      discoveredAt: new Date(Date.now() - 36e5).toISOString(),
+      // 1 hour ago
+      buildTimestamp: new Date(Date.now() - 54e5).toISOString(),
+      // 1.5 hours ago
+      manifest: {
+        schema: "kb.plugin/3",
+        id: "@kb-labs/workflow-plugin",
+        version: "1.0.0",
+        display: {
+          name: "Workflow Engine",
+          description: "Orchestrate multi-step workflows",
+          author: "KB Labs",
+          icon: "\u2699\uFE0F",
+          tags: ["workflow", "automation", "orchestration"]
+        },
+        permissions: {
+          fs: { mode: "readwrite", allow: [".kb/workflows/**"] }
+        },
+        platform: {
+          requires: ["storage", "cache"]
+        },
+        cli: {
+          commands: [
+            {
+              id: "run",
+              group: "workflow",
+              describe: "Run a workflow",
+              handler: "./dist/commands/run.js",
+              flags: [
+                { name: "workflow-id", type: "string", required: true },
+                { name: "input", type: "string" }
+              ]
+            }
+          ]
+        },
+        rest: {
+          basePath: "/v1/plugins/workflow",
+          routes: [
+            {
+              method: "POST",
+              path: "/execute",
+              description: "Execute workflow",
+              handler: "./dist/rest/execute.js",
+              input: { $ref: "#/components/schemas/WorkflowExecuteRequest" },
+              output: { $ref: "#/components/schemas/WorkflowExecuteResponse" }
+            },
+            {
+              method: "GET",
+              path: "/status/:runId",
+              description: "Get workflow status",
+              handler: "./dist/rest/status.js",
+              output: { $ref: "#/components/schemas/WorkflowStatus" }
+            }
+          ]
+        },
+        jobs: {
+          handlers: [
+            {
+              id: "cleanup-old-runs",
+              handler: "./dist/jobs/cleanup.js",
+              describe: "Clean up old workflow runs"
+            }
+          ],
+          cron: [
+            {
+              jobId: "cleanup-old-runs",
+              schedule: "0 2 * * *",
+              enabled: true
+            }
+          ]
+        }
+      }
+    }
+  ]
+};
+var MockPluginsSource = class {
+  async getPlugins() {
+    await new Promise((resolve) => {
+      setTimeout(() => resolve(), 300);
+    });
+    return {
+      ...mockManifests,
+      apiBasePath: "/api/v1"
+    };
+  }
+  async askAboutPlugin(pluginId, request) {
+    await new Promise((resolve) => {
+      setTimeout(() => resolve(), 1e3);
+    });
+    const question = request.question.toLowerCase();
+    let answer = "";
+    if (question.includes("permission") || question.includes("access")) {
+      answer = `This plugin requires the following permissions:
+
+- File System: Read-only access to .kb/** and src/** directories
+- Network: Access to api.openai.com for AI operations
+
+These permissions are necessary for RAG indexing and semantic search functionality.`;
+    } else if (question.includes("command") || question.includes("cli")) {
+      answer = `The plugin provides 2 CLI commands:
+
+1. **rag-query** - Query the RAG index
+   - Required: --text (query text)
+   - Optional: --agent (use agent mode)
+
+2. **rag-index** - Build RAG index
+   - Optional: --scope (default: 'default')
+
+Use these commands to perform semantic code search across your codebase.`;
+    } else if (question.includes("rest") || question.includes("api") || question.includes("endpoint")) {
+      answer = `The plugin exposes 1 REST API endpoint:
+
+**POST /v1/plugins/mind/search** - Semantic code search
+- Timeout: 30 seconds
+- Input: SearchInputSchema (query text and options)
+- Output: SearchOutputSchema (search results with relevance scores)
+
+This endpoint allows integration with external tools and web interfaces.`;
+    } else {
+      answer = `This is the Mind RAG Plugin (v0.1.0) - a semantic code search and RAG system.
+
+Key features:
+- 2 CLI commands (rag-query, rag-index)
+- 1 REST API endpoint (/search)
+- AI-powered semantic search
+- Read-only file system access
+- OpenAI API integration
+
+The plugin helps developers find relevant code using natural language queries.`;
+    }
+    return {
+      answer,
+      usage: {
+        promptTokens: 150,
+        completionTokens: 100
+      }
+    };
+  }
+};
+
+// src/factory.ts
+function createDataSources(config) {
+  if (config.mode === "mock") {
+    return {
+      system: new MockSystemSource(),
+      workflow: new MockWorkflowSource(),
+      cache: new MockCacheSource(),
+      observability: new MockObservabilitySource(),
+      analytics: new MockAnalyticsSource(),
+      adapters: new MockAdaptersSource(),
+      platform: new MockPlatformSource(),
+      plugins: new MockPluginsSource()
+    };
+  }
+  const baseUrl = config.baseUrl || "";
+  const client = new HttpClient(baseUrl, config.token);
+  return {
+    system: new HttpSystemSource(client),
+    workflow: new HttpWorkflowSource(client),
+    cache: new HttpCacheSource(client),
+    observability: new HttpObservabilitySource(client),
+    analytics: new HttpAnalyticsSource(client),
+    adapters: new HttpAdaptersSource(client),
+    platform: new HttpPlatformSource(client),
+    plugins: new HttpPluginsSource(client)
+  };
+}
+
+// src/query-keys.ts
+var qk = {
+  // Audit queries
+  audit: {
+    all: ["audit"],
+    summary: () => [...qk.audit.all, "summary"],
+    runs: {
+      all: () => [...qk.audit.all, "runs"],
+      list: (params) => [...qk.audit.runs.all(), "list", params],
+      byId: (runId) => [...qk.audit.runs.all(), "detail", runId]
+    },
+    report: {
+      latest: () => [...qk.audit.all, "report", "latest"],
+      byRunId: (runId) => [...qk.audit.all, "report", runId]
+    },
+    pkg: (name) => [...qk.audit.all, "pkg", name]
+  },
+  // Release queries
+  release: {
+    all: ["release"],
+    preview: (params) => [...qk.release.all, "preview", params],
+    runs: {
+      all: () => [...qk.release.all, "runs"],
+      byId: (runId) => [...qk.release.runs.all(), "detail", runId]
+    },
+    changelog: (params) => [...qk.release.all, "changelog", params]
+  },
+  // Jobs queries
+  jobs: {
+    all: ["jobs"],
+    byId: (jobId) => [...qk.jobs.all, "detail", jobId],
+    logs: {
+      byJobId: (jobId, offset) => [...qk.jobs.all, "logs", jobId, offset],
+      stream: (jobId) => [...qk.jobs.all, "logs", "stream", jobId]
+    },
+    events: (jobId) => [...qk.jobs.all, "events", jobId],
+    list: (params) => [...qk.jobs.all, "list", params]
+  },
+  // System queries
+  system: {
+    all: ["system"],
+    health: {
+      live: () => [...qk.system.all, "health", "live"],
+      ready: () => [...qk.system.all, "health", "ready"]
+    },
+    info: () => [...qk.system.all, "info"],
+    capabilities: () => [...qk.system.all, "capabilities"],
+    config: () => [...qk.system.all, "config"]
+  },
+  workflows: {
+    all: ["workflows"],
+    list: (filters) => [...qk.workflows.all, "list", filters ?? {}],
+    run: (runId) => [...qk.workflows.all, "run", runId]
+  },
+  // DevLink queries
+  devlink: {
+    all: ["devlink"],
+    summary: () => [...qk.devlink.all, "summary"],
+    graph: () => [...qk.devlink.all, "graph"]
+  },
+  // Mind queries
+  mind: {
+    all: ["mind"],
+    summary: () => [...qk.mind.all, "summary"]
+  },
+  // Analytics queries
+  analytics: {
+    all: ["analytics"],
+    summary: (params) => [...qk.analytics.all, "summary", params]
+  },
+  // Platform queries
+  platform: {
+    all: ["platform"],
+    config: () => [...qk.platform.all, "config"]
+  }
+};
+var queryKeys = qk;
+function useHealthStatus(source) {
+  return useQuery({
+    queryKey: qk.system.health.live(),
+    queryFn: async () => {
+      try {
+        return source.getHealth();
+      } catch (error) {
+        return {
+          ok: false,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          sources: [{
+            name: "system",
+            ok: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          }]
+        };
+      }
+    },
+    refetchInterval: 3e4,
+    // Poll every 30 seconds
+    staleTime: 15e3,
+    retry: 2,
+    retryDelay: 1e3
+  });
+}
+function useReadyStatus(source) {
+  const httpSource = source;
+  return useQuery({
+    queryKey: qk.system.health.ready(),
+    queryFn: async () => {
+      if (httpSource.getReady) {
+        return httpSource.getReady();
+      }
+      return {
+        ready: true
+      };
+    },
+    refetchInterval: 3e4,
+    staleTime: 15e3,
+    retry: 2,
+    retryDelay: 1e3
+  });
+}
+function useSystemInfo(source) {
+  const httpSource = source;
+  return useQuery({
+    queryKey: qk.system.info(),
+    queryFn: async () => {
+      if (httpSource.getInfo) {
+        return httpSource.getInfo();
+      }
+      return {
+        cwd: process.cwd(),
+        repo: void 0,
+        profiles: [],
+        plugins: [],
+        apiVersion: "1.0.0"
+      };
+    },
+    staleTime: 6e4
+    // Cache for 1 minute
+  });
+}
+function useCapabilities(source) {
+  const httpSource = source;
+  return useQuery({
+    queryKey: qk.system.capabilities(),
+    queryFn: async () => {
+      if (httpSource.getCapabilities) {
+        return httpSource.getCapabilities();
+      }
+      return {
+        commands: ["audit", "release", "devlink", "mind", "analytics"],
+        adapters: {
+          queue: ["memory"],
+          storage: ["fs"],
+          auth: ["none"]
+        }
+      };
+    },
+    staleTime: 6e4
+  });
+}
+function useWorkflowRuns(source, filters) {
+  const queryKey = useMemo(() => qk.workflows.list(filters), [filters]);
+  return useQuery({
+    queryKey,
+    queryFn: async () => {
+      return source.listRuns(filters);
+    }
+  });
+}
+function useWorkflowRun(runId, source) {
+  return useQuery({
+    queryKey: qk.workflows.run(runId ?? ""),
+    enabled: Boolean(runId),
+    queryFn: async () => {
+      if (!runId) {
+        return null;
+      }
+      return source.getRun(runId);
+    }
+  });
+}
+function useCancelWorkflowRun(source) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (runId) => source.cancelRun(runId),
+    onSuccess: (run) => {
+      void queryClient.invalidateQueries({ queryKey: qk.workflows.all, exact: false });
+      if (run?.id) {
+        void queryClient.invalidateQueries({ queryKey: qk.workflows.run(run.id) });
+      }
+    }
+  });
+}
+function useRunWorkflow(source) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      if (!source.runWorkflow) {
+        throw new Error("Workflow source does not support running workflows");
+      }
+      return source.runWorkflow(params);
+    },
+    onSuccess: (run) => {
+      void queryClient.invalidateQueries({ queryKey: qk.workflows.all, exact: false });
+      if (run?.id) {
+        void queryClient.invalidateQueries({ queryKey: qk.workflows.run(run.id) });
+      }
+    }
+  });
+}
+function useResolveApproval(source) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      if (!source.resolveApproval) {
+        throw new Error("Workflow source does not support approvals");
+      }
+      return source.resolveApproval(params);
+    },
+    onSuccess: (_data, variables) => {
+      void queryClient.invalidateQueries({ queryKey: qk.workflows.run(variables.runId) });
+    }
+  });
+}
+function useWorkflowLogs(runId, options = {}) {
+  const { follow = true, idleTimeoutMs, enabled = true, baseUrl = "" } = options;
+  const [events, setEvents] = useState([]);
+  const [error, setError] = useState(null);
+  const [isConnected, setIsConnected] = useState(false);
+  useEffect(() => {
+    if (!runId || !enabled) {
+      setIsConnected(false);
+      setError(null);
+      return;
+    }
+    setEvents([]);
+    setError(null);
+    const params = new URLSearchParams();
+    if (follow) {
+      params.set("follow", "1");
+    }
+    if (typeof idleTimeoutMs === "number") {
+      params.set("idleTimeoutMs", String(idleTimeoutMs));
+    }
+    const url = `${baseUrl}/workflows/runs/${runId}/logs${params.toString() ? `?${params}` : ""}`;
+    const eventSource = new EventSource(url);
+    const handleMessage = (event) => {
+      try {
+        const payload = JSON.parse(event.data);
+        setEvents((prev) => [...prev, payload]);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to parse workflow log event"));
+      }
+    };
+    eventSource.addEventListener("workflow.log", handleMessage);
+    eventSource.addEventListener("workflow.done", () => {
+      setIsConnected(false);
+      eventSource.close();
+    });
+    eventSource.onopen = () => {
+      setIsConnected(true);
+      setError(null);
+    };
+    eventSource.onerror = (_event) => {
+      setIsConnected(false);
+      setError(new Error("Workflow log stream disconnected"));
+      eventSource.close();
+    };
+    return () => {
+      eventSource.removeEventListener("workflow.log", handleMessage);
+      eventSource.close();
+    };
+  }, [runId, follow, idleTimeoutMs, enabled]);
+  return {
+    events,
+    error,
+    isConnected
+  };
+}
+function useWorkflowEvents(runId, options = {}) {
+  const { follow = true, pollIntervalMs, cursor, enabled = true, baseUrl = "" } = options;
+  const [events, setEvents] = useState([]);
+  const [error, setError] = useState(null);
+  const [isConnected, setIsConnected] = useState(false);
+  useEffect(() => {
+    if (!runId || !enabled) {
+      return;
+    }
+    setEvents([]);
+    setError(null);
+    const params = new URLSearchParams();
+    if (follow) {
+      params.set("follow", "1");
+    }
+    if (typeof pollIntervalMs === "number") {
+      params.set("pollIntervalMs", String(pollIntervalMs));
+    }
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    const url = `${baseUrl}/workflows/runs/${runId}/events${params.toString() ? `?${params}` : ""}`;
+    const eventSource = new EventSource(url);
+    const handleMessage = (event) => {
+      try {
+        const payload = JSON.parse(event.data);
+        setEvents((prev) => [...prev, payload]);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to parse workflow event"));
+      }
+    };
+    eventSource.addEventListener("workflow.event", handleMessage);
+    eventSource.onopen = () => {
+      setIsConnected(true);
+      setError(null);
+    };
+    eventSource.onerror = () => {
+      setIsConnected(false);
+      setError(new Error("Workflow event stream disconnected"));
+      eventSource.close();
+    };
+    return () => {
+      eventSource.removeEventListener("workflow.event", handleMessage);
+      eventSource.close();
+    };
+  }, [runId, follow, pollIntervalMs, cursor, enabled]);
+  return {
+    events,
+    error,
+    isConnected
+  };
+}
+function useStateBrokerStats(source) {
+  return useQuery({
+    queryKey: ["observability", "state-broker"],
+    queryFn: () => source.getStateBrokerStats(),
+    refetchInterval: 5e3,
+    // Auto-refresh every 5s for real-time updates
+    staleTime: 3e3,
+    // Consider data stale after 3s
+    retry: 2
+    // Retry failed requests twice
+  });
+}
+function useDevKitHealth(source) {
+  return useQuery({
+    queryKey: ["observability", "devkit"],
+    queryFn: () => source.getDevKitHealth(),
+    staleTime: 6e4,
+    // Cache for 1 minute
+    gcTime: 3e5,
+    // Keep in cache for 5 minutes (React Query v5)
+    retry: 1
+    // DevKit can be slow, only retry once
+  });
+}
+function usePrometheusMetrics(source) {
+  return useQuery({
+    queryKey: ["observability", "prometheus-metrics"],
+    queryFn: () => source.getPrometheusMetrics(),
+    refetchInterval: 1e4,
+    // Auto-refresh every 10s
+    staleTime: 8e3,
+    // Consider data stale after 8s
+    retry: 2
+    // Retry failed requests twice
+  });
+}
+function useSystemEvents(source) {
+  const [events, setEvents] = useState([]);
+  const [isConnected, setIsConnected] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    setIsConnected(true);
+    setError(null);
+    const cleanup = source.subscribeToSystemEvents(
+      (event) => {
+        setEvents((prev) => [event, ...prev].slice(0, 100));
+      },
+      (err) => {
+        setIsConnected(false);
+        setError(err);
+      }
+    );
+    return () => {
+      cleanup();
+      setIsConnected(false);
+    };
+  }, [source]);
+  return { events, isConnected, error };
+}
+function useLogStream(source, filters) {
+  const [logs, setLogs] = useState([]);
+  const [isConnected, setIsConnected] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    setIsConnected(true);
+    setError(null);
+    const cleanup = source.subscribeToLogs(
+      (log) => {
+        setLogs((prev) => [log, ...prev].slice(0, 500));
+      },
+      (err) => {
+        setIsConnected(false);
+        setError(err);
+      },
+      filters
+    );
+    return () => {
+      cleanup();
+      setIsConnected(false);
+    };
+  }, [source, filters]);
+  const clearLogs = () => setLogs([]);
+  return { logs, isConnected, error, clearLogs };
+}
+function useMetricsHistory(source, query) {
+  return useQuery({
+    queryKey: ["observability", "metrics-history", query.metric, query.range, query.interval],
+    queryFn: () => source.getMetricsHistory(query),
+    refetchInterval: 5e3,
+    // Auto-refresh every 5s
+    staleTime: 3e3,
+    // Consider data stale after 3s
+    retry: 2
+  });
+}
+function useMetricsHeatmap(source, query) {
+  return useQuery({
+    queryKey: ["observability", "metrics-heatmap", query.metric, query.days],
+    queryFn: () => source.getMetricsHeatmap(query),
+    staleTime: 6e4,
+    // Cache for 1 minute
+    gcTime: 3e5,
+    // Keep in cache for 5 minutes
+    retry: 2
+  });
+}
+function useIncidents(source, query) {
+  return useQuery({
+    queryKey: ["observability", "incidents", query],
+    queryFn: () => source.queryIncidents(query),
+    refetchInterval: 3e4,
+    // Auto-refresh every 30s
+    staleTime: 2e4,
+    // Consider data stale after 20s
+    retry: 2
+  });
+}
+function useAnalyticsEvents(source, query) {
+  return useQuery({
+    queryKey: ["analytics", "events", query],
+    queryFn: () => source.getEvents(query),
+    refetchInterval: 3e4,
+    // Auto-refresh every 30s
+    staleTime: 25e3,
+    // Consider data stale after 25s
+    retry: 2
+  });
+}
+function useAnalyticsStats(source) {
+  return useQuery({
+    queryKey: ["analytics", "stats"],
+    queryFn: () => source.getStats(),
+    refetchInterval: 3e4,
+    // Auto-refresh every 30s
+    staleTime: 25e3,
+    retry: 2
+  });
+}
+function useAnalyticsBufferStatus(source) {
+  return useQuery({
+    queryKey: ["analytics", "buffer"],
+    queryFn: () => source.getBufferStatus(),
+    refetchInterval: 1e4,
+    // Auto-refresh every 10s
+    staleTime: 8e3,
+    retry: 2
+  });
+}
+function useAnalyticsDlqStatus(source) {
+  return useQuery({
+    queryKey: ["analytics", "dlq"],
+    queryFn: () => source.getDlqStatus(),
+    refetchInterval: 15e3,
+    // Auto-refresh every 15s
+    staleTime: 12e3,
+    retry: 2
+  });
+}
+var DAILY_STATS = "daily-stats";
+function useAdaptersLLMUsage(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "llm", "usage", options?.from, options?.to],
+    queryFn: () => source.getLLMUsage(options),
+    refetchInterval: 6e4,
+    // Auto-refresh every 60s (LLM stats change slower)
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function useAdaptersEmbeddingsUsage(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "embeddings", "usage", options?.from, options?.to],
+    queryFn: () => source.getEmbeddingsUsage(options),
+    refetchInterval: 6e4,
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function useAdaptersVectorStoreUsage(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "vectorstore", "usage", options?.from, options?.to],
+    queryFn: () => source.getVectorStoreUsage(options),
+    refetchInterval: 6e4,
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function useAdaptersCacheUsage(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "cache", "usage", options?.from, options?.to],
+    queryFn: () => source.getCacheUsage(options),
+    refetchInterval: 3e4,
+    // Cache stats change faster - refresh every 30s
+    staleTime: 25e3,
+    retry: 2
+  });
+}
+function useAdaptersStorageUsage(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "storage", "usage", options?.from, options?.to],
+    queryFn: () => source.getStorageUsage(options),
+    refetchInterval: 6e4,
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function useAdaptersLLMDailyStats(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "llm", DAILY_STATS, options?.from, options?.to, options?.models],
+    queryFn: () => source.getLLMDailyStats(options),
+    refetchInterval: 6e4,
+    // Daily stats change slower
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function useAdaptersEmbeddingsDailyStats(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "embeddings", DAILY_STATS, options?.from, options?.to],
+    queryFn: () => source.getEmbeddingsDailyStats(options),
+    refetchInterval: 6e4,
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function useAdaptersVectorStoreDailyStats(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "vectorstore", DAILY_STATS, options?.from, options?.to],
+    queryFn: () => source.getVectorStoreDailyStats(options),
+    refetchInterval: 6e4,
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function useAdaptersCacheDailyStats(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "cache", DAILY_STATS, options?.from, options?.to],
+    queryFn: () => source.getCacheDailyStats(options),
+    refetchInterval: 3e4,
+    // Cache stats change faster
+    staleTime: 25e3,
+    retry: 2
+  });
+}
+function useAdaptersStorageDailyStats(source, options) {
+  return useQuery({
+    queryKey: ["adapters", "storage", DAILY_STATS, options?.from, options?.to],
+    queryFn: () => source.getStorageDailyStats(options),
+    refetchInterval: 6e4,
+    staleTime: 5e4,
+    retry: 2
+  });
+}
+function usePlatformConfig(source) {
+  return useQuery({
+    queryKey: qk.platform.config(),
+    queryFn: async () => {
+      return source.getConfig();
+    },
+    staleTime: 6e4,
+    // Cache for 1 minute (config rarely changes)
+    retry: 2,
+    retryDelay: 1e3
+  });
+}
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function statusToEventType(status) {
+  if (status === "completed") {
+    return "job.finished";
+  }
+  if (status === "failed") {
+    return "job.failed";
+  }
+  if (status === "running") {
+    return "job.started";
+  }
+  return "job.queued";
+}
+function useJobEvents(jobId, options = {}) {
+  const {
+    enabled = true,
+    pollInterval = 1e3,
+    baseUrl = "",
+    onEvent,
+    onError,
+    onComplete
+  } = options;
+  const [events, setEvents] = useState([]);
+  const [isConnected, setIsConnected] = useState(false);
+  const [error, setError] = useState(null);
+  const eventSourceRef = useRef(null);
+  const pollingRef = useRef(null);
+  const useSSERef = useRef(true);
+  const reconnect = useCallback(() => {
+    if (eventSourceRef.current) {
+      eventSourceRef.current.close();
+      eventSourceRef.current = null;
+    }
+    if (pollingRef.current) {
+      clearInterval(pollingRef.current);
+      pollingRef.current = null;
+    }
+    setEvents([]);
+    setError(null);
+    setIsConnected(false);
+    useSSERef.current = true;
+  }, []);
+  useEffect(() => {
+    if (!enabled || !jobId) {
+      return;
+    }
+    const eventsUrl = `${baseUrl}/jobs/${jobId}/events`;
+    if (useSSERef.current) {
+      try {
+        const eventSource = new EventSource(eventsUrl);
+        eventSourceRef.current = eventSource;
+        eventSource.onopen = () => {
+          setIsConnected(true);
+          setError(null);
+        };
+        eventSource.onmessage = (e) => {
+          try {
+            const event = JSON.parse(e.data);
+            setEvents((prev) => [...prev, event]);
+            onEvent?.(event);
+            if (event.type === "job.finished" || event.type === "job.failed") {
+              eventSource.close();
+              setIsConnected(false);
+              onComplete?.();
+            }
+          } catch (_err) {
+            setError(_err instanceof Error ? _err : new Error("Failed to parse event"));
+            onError?.(_err instanceof Error ? _err : new Error("Failed to parse event"));
+          }
+        };
+        eventSource.onerror = (_event) => {
+          eventSource.close();
+          eventSourceRef.current = null;
+          useSSERef.current = false;
+          setIsConnected(false);
+          const poll = async () => {
+            try {
+              const response = await fetch(`${baseUrl}/jobs/${jobId}`);
+              if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+              }
+              const data = await response.json();
+              const currentStatus = data.status;
+              const lastEvent = events[events.length - 1];
+              if (!lastEvent || lastEvent.data?.status !== currentStatus) {
+                const event = {
+                  type: statusToEventType(currentStatus),
+                  jobId,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  data: {
+                    status: currentStatus,
+                    progress: data.progress,
+                    error: data.error
+                  }
+                };
+                setEvents((prev) => [...prev, event]);
+                onEvent?.(event);
+                if (TERMINAL_STATUSES.has(currentStatus)) {
+                  if (pollingRef.current) {
+                    clearInterval(pollingRef.current);
+                    pollingRef.current = null;
+                  }
+                  onComplete?.();
+                }
+              }
+            } catch (_err) {
+              const errorInstance = _err instanceof Error ? _err : new Error("Polling failed");
+              setError(errorInstance);
+              onError?.(errorInstance);
+            }
+          };
+          poll();
+          pollingRef.current = setInterval(poll, pollInterval);
+        };
+        return () => {
+          if (eventSourceRef.current) {
+            eventSourceRef.current.close();
+            eventSourceRef.current = null;
+          }
+          if (pollingRef.current) {
+            clearInterval(pollingRef.current);
+            pollingRef.current = null;
+          }
+        };
+      } catch (_err) {
+        useSSERef.current = false;
+      }
+    }
+    if (!useSSERef.current && !pollingRef.current) {
+      const poll = async () => {
+        try {
+          const response = await fetch(`${baseUrl}/jobs/${jobId}`);
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+          const data = await response.json();
+          const currentStatus = data.status;
+          setEvents((prev) => {
+            const lastEvent = prev[prev.length - 1];
+            if (!lastEvent || lastEvent.data?.status !== currentStatus) {
+              const event = {
+                type: statusToEventType(currentStatus),
+                jobId,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: {
+                  status: currentStatus,
+                  progress: data.progress,
+                  error: data.error
+                }
+              };
+              onEvent?.(event);
+              if (currentStatus === "completed" || currentStatus === "failed" || currentStatus === "cancelled") {
+                if (pollingRef.current) {
+                  clearInterval(pollingRef.current);
+                  pollingRef.current = null;
+                }
+                onComplete?.();
+              }
+              return [...prev, event];
+            }
+            return prev;
+          });
+          setIsConnected(true);
+          setError(null);
+        } catch (_err) {
+          const errorInstance = _err instanceof Error ? _err : new Error("Polling failed");
+          setError(errorInstance);
+          onError?.(errorInstance);
+          setIsConnected(false);
+        }
+      };
+      poll();
+      pollingRef.current = setInterval(poll, pollInterval);
+      return () => {
+        if (pollingRef.current) {
+          clearInterval(pollingRef.current);
+          pollingRef.current = null;
+        }
+      };
+    }
+  }, [jobId, enabled, pollInterval, onEvent, onError, onComplete, events]);
+  return {
+    events,
+    isConnected,
+    error,
+    reconnect
+  };
+}
+var MAX_NOTIFICATIONS = 50;
+function useNotifications(source, maxNotifications = MAX_NOTIFICATIONS) {
+  const [notifications, setNotifications] = useState([]);
+  useEffect(() => {
+    return source.subscribeToLogs(
+      (log) => {
+        if (log.level !== "warn" && log.level !== "error") {
+          return;
+        }
+        let messageText = "No message";
+        if (log.msg) {
+          messageText = typeof log.msg === "string" ? log.msg : JSON.stringify(log.msg);
+        }
+        const notification = {
+          id: log.id || `${log.time}-${Math.random().toString(36).slice(2, 9)}`,
+          // Use log.id from database, fallback to generated
+          timestamp: log.time,
+          level: log.level,
+          message: messageText,
+          plugin: log.plugin,
+          executionId: log.executionId,
+          error: log.err ? {
+            name: String(log.err.name || "Error"),
+            message: String(log.err.message || "Unknown error")
+          } : void 0,
+          read: false
+        };
+        setNotifications((prev) => [notification, ...prev].slice(0, maxNotifications));
+      },
+      (err) => {
+        console.error("Notifications SSE error:", err);
+      }
+    );
+  }, [source, maxNotifications]);
+  const unreadCount = notifications.filter((n) => !n.read).length;
+  const markAsRead = useCallback((id) => {
+    setNotifications(
+      (prev) => prev.map((n) => n.id === id ? { ...n, read: true } : n)
+    );
+  }, []);
+  const markAllAsRead = useCallback(() => {
+    setNotifications((prev) => prev.map((n) => ({ ...n, read: true })));
+  }, []);
+  const clearAll = useCallback(() => {
+    setNotifications([]);
+  }, []);
+  const clearNotification = useCallback((id) => {
+    setNotifications((prev) => prev.filter((n) => n.id !== id));
+  }, []);
+  return {
+    notifications,
+    unreadCount,
+    markAsRead,
+    markAllAsRead,
+    clearAll,
+    clearNotification
+  };
+}
+
+export { HttpAdaptersSource, HttpAnalyticsSource, HttpCacheSource, HttpClient, HttpObservabilitySource, HttpPlatformSource, HttpPluginsSource, HttpSystemSource, HttpWorkflowSource, KBError, MockAdaptersSource, MockAnalyticsSource, MockCacheSource, MockObservabilitySource, MockPlatformSource, MockPluginsSource, MockSystemSource, MockWorkflowSource, SCHEMA_VERSION, actionResultSchema, auditCheckSchema, auditPackageReportSchema, auditSummarySchema, createDataSources, createEnvelopeInterceptor, errorCodes, extractEnvelopeMeta, healthStatusSchema, idSchema, isoDateSchema, mapErrorEnvelope, mapFetchError, packageRefSchema, qk, queryKeys, releasePreviewSchema, runRefSchema, useAdaptersCacheDailyStats, useAdaptersCacheUsage, useAdaptersEmbeddingsDailyStats, useAdaptersEmbeddingsUsage, useAdaptersLLMDailyStats, useAdaptersLLMUsage, useAdaptersStorageDailyStats, useAdaptersStorageUsage, useAdaptersVectorStoreDailyStats, useAdaptersVectorStoreUsage, useAnalyticsBufferStatus, useAnalyticsDlqStatus, useAnalyticsEvents, useAnalyticsStats, useCancelWorkflowRun, useCapabilities, useDevKitHealth, useHealthStatus, useIncidents, useJobEvents, useLogStream, useMetricsHeatmap, useMetricsHistory, useNotifications, usePlatformConfig, usePrometheusMetrics, useReadyStatus, useResolveApproval, useRunWorkflow, useStateBrokerStats, useSystemEvents, useSystemInfo, useWorkflowEvents, useWorkflowLogs, useWorkflowRun, useWorkflowRuns };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map