peak6-x-intelligence-plugin 0.1.0

package/dist/worker.js

@@ -0,0 +1,2060 @@
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/define-plugin.js
+function definePlugin(definition) {
+  return Object.freeze({ definition });
+}
+
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/worker-rpc-host.js
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/protocol.js
+var JSONRPC_VERSION = "2.0";
+var JSONRPC_ERROR_CODES = {
+  /** Invalid JSON was received by the server. */
+  PARSE_ERROR: -32700,
+  /** The JSON sent is not a valid Request object. */
+  INVALID_REQUEST: -32600,
+  /** The method does not exist or is not available. */
+  METHOD_NOT_FOUND: -32601,
+  /** Invalid method parameter(s). */
+  INVALID_PARAMS: -32602,
+  /** Internal JSON-RPC error. */
+  INTERNAL_ERROR: -32603
+};
+var PLUGIN_RPC_ERROR_CODES = {
+  /** The worker process is not running or not reachable. */
+  WORKER_UNAVAILABLE: -32e3,
+  /** The plugin does not have the required capability for this operation. */
+  CAPABILITY_DENIED: -32001,
+  /** The worker reported an unhandled error during method execution. */
+  WORKER_ERROR: -32002,
+  /** The method call timed out waiting for the worker response. */
+  TIMEOUT: -32003,
+  /** The worker does not implement the requested optional method. */
+  METHOD_NOT_IMPLEMENTED: -32004,
+  /** A catch-all for errors that do not fit other categories. */
+  UNKNOWN: -32099
+};
+var _nextId = 1;
+var MAX_SAFE_RPC_ID = Number.MAX_SAFE_INTEGER - 1;
+function createRequest(method, params, id) {
+  if (_nextId >= MAX_SAFE_RPC_ID) {
+    _nextId = 1;
+  }
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id: id ?? _nextId++,
+    method,
+    params
+  };
+}
+function createSuccessResponse(id, result) {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    result
+  };
+}
+function createErrorResponse(id, code, message, data) {
+  const response = {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    error: data !== void 0 ? { code, message, data } : { code, message }
+  };
+  return response;
+}
+function createNotification(method, params) {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    method,
+    params
+  };
+}
+function isJsonRpcRequest(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return obj.jsonrpc === JSONRPC_VERSION && typeof obj.method === "string" && "id" in obj && obj.id !== void 0 && obj.id !== null;
+}
+function isJsonRpcNotification(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return obj.jsonrpc === JSONRPC_VERSION && typeof obj.method === "string" && !("id" in obj);
+}
+function isJsonRpcResponse(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  return obj.jsonrpc === JSONRPC_VERSION && "id" in obj && ("result" in obj || "error" in obj);
+}
+function isJsonRpcSuccessResponse(response) {
+  return "result" in response && !("error" in response && response.error !== void 0);
+}
+function isJsonRpcErrorResponse(response) {
+  return "error" in response && response.error !== void 0;
+}
+var MESSAGE_DELIMITER = "\n";
+function serializeMessage(message) {
+  return JSON.stringify(message) + MESSAGE_DELIMITER;
+}
+function parseMessage(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    throw new JsonRpcParseError("Empty message");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new JsonRpcParseError(`Invalid JSON: ${trimmed.slice(0, 200)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new JsonRpcParseError("Message must be a JSON object");
+  }
+  const obj = parsed;
+  if (obj.jsonrpc !== JSONRPC_VERSION) {
+    throw new JsonRpcParseError(`Invalid or missing jsonrpc version (expected "${JSONRPC_VERSION}", got ${JSON.stringify(obj.jsonrpc)})`);
+  }
+  return parsed;
+}
+var JsonRpcParseError = class extends Error {
+  name = "JsonRpcParseError";
+  constructor(message) {
+    super(message);
+  }
+};
+var JsonRpcCallError = class extends Error {
+  name = "JsonRpcCallError";
+  /** The JSON-RPC error code. */
+  code;
+  /** Optional structured error data from the response. */
+  data;
+  constructor(error) {
+    super(error.message);
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+
+// node_modules/.pnpm/@paperclipai+plugin-sdk@file+.paperclip-sdk+paperclipai-plugin-sdk-1.0.0.tgz_react@19.2.4/node_modules/@paperclipai/plugin-sdk/dist/worker-rpc-host.js
+var DEFAULT_RPC_TIMEOUT_MS = 3e4;
+function runWorker(plugin2, moduleUrl, options) {
+  if (options?.stdin != null && options?.stdout != null) {
+    return startWorkerRpcHost({
+      plugin: plugin2,
+      stdin: options.stdin,
+      stdout: options.stdout
+    });
+  }
+  const entry = process.argv[1];
+  if (typeof entry !== "string")
+    return;
+  const thisFile = path.resolve(fileURLToPath(moduleUrl));
+  const entryPath = path.resolve(entry);
+  if (thisFile === entryPath) {
+    startWorkerRpcHost({ plugin: plugin2 });
+  }
+}
+function startWorkerRpcHost(options) {
+  const { plugin: plugin2 } = options;
+  const stdinStream = options.stdin ?? process.stdin;
+  const stdoutStream = options.stdout ?? process.stdout;
+  const rpcTimeoutMs = options.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS;
+  let running = true;
+  let initialized = false;
+  let manifest = null;
+  let currentConfig = {};
+  const eventHandlers = [];
+  const jobHandlers = /* @__PURE__ */ new Map();
+  const launcherRegistrations = /* @__PURE__ */ new Map();
+  const dataHandlers = /* @__PURE__ */ new Map();
+  const actionHandlers = /* @__PURE__ */ new Map();
+  const toolHandlers = /* @__PURE__ */ new Map();
+  const sessionEventCallbacks = /* @__PURE__ */ new Map();
+  const pendingRequests = /* @__PURE__ */ new Map();
+  let nextOutboundId = 1;
+  const MAX_OUTBOUND_ID = Number.MAX_SAFE_INTEGER - 1;
+  function sendMessage(message) {
+    if (!running)
+      return;
+    const serialized = serializeMessage(message);
+    stdoutStream.write(serialized);
+  }
+  function callHost(method, params, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      if (!running) {
+        reject(new Error(`Cannot call "${method}" \u2014 worker RPC host is not running`));
+        return;
+      }
+      if (nextOutboundId >= MAX_OUTBOUND_ID) {
+        nextOutboundId = 1;
+      }
+      const id = nextOutboundId++;
+      const timeout = timeoutMs ?? rpcTimeoutMs;
+      let settled = false;
+      const settle = (fn, value) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        pendingRequests.delete(id);
+        fn(value);
+      };
+      const timer = setTimeout(() => {
+        settle(reject, new JsonRpcCallError({
+          code: PLUGIN_RPC_ERROR_CODES.TIMEOUT,
+          message: `Worker\u2192host call "${method}" timed out after ${timeout}ms`
+        }));
+      }, timeout);
+      pendingRequests.set(id, {
+        resolve: (response) => {
+          if (isJsonRpcSuccessResponse(response)) {
+            settle(resolve, response.result);
+          } else if (isJsonRpcErrorResponse(response)) {
+            settle(reject, new JsonRpcCallError(response.error));
+          } else {
+            settle(reject, new Error(`Unexpected response format for "${method}"`));
+          }
+        },
+        timer
+      });
+      try {
+        const request = createRequest(method, params, id);
+        sendMessage(request);
+      } catch (err) {
+        settle(reject, err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  function notifyHost(method, params) {
+    try {
+      sendMessage(createNotification(method, params));
+    } catch {
+    }
+  }
+  function buildContext() {
+    return {
+      get manifest() {
+        if (!manifest)
+          throw new Error("Plugin context accessed before initialization");
+        return manifest;
+      },
+      config: {
+        async get() {
+          return callHost("config.get", {});
+        }
+      },
+      events: {
+        on(name, filterOrFn, maybeFn) {
+          let registration;
+          if (typeof filterOrFn === "function") {
+            registration = { name, fn: filterOrFn };
+          } else {
+            if (!maybeFn)
+              throw new Error("Event handler function is required");
+            registration = { name, filter: filterOrFn, fn: maybeFn };
+          }
+          eventHandlers.push(registration);
+          void callHost("events.subscribe", { eventPattern: name, filter: registration.filter ?? null }).catch((err) => {
+            notifyHost("log", {
+              level: "warn",
+              message: `Failed to subscribe to event "${name}" on host: ${err instanceof Error ? err.message : String(err)}`
+            });
+          });
+          return () => {
+            const idx = eventHandlers.indexOf(registration);
+            if (idx !== -1)
+              eventHandlers.splice(idx, 1);
+          };
+        },
+        async emit(name, companyId, payload) {
+          await callHost("events.emit", { name, companyId, payload });
+        }
+      },
+      jobs: {
+        register(key, fn) {
+          jobHandlers.set(key, fn);
+        }
+      },
+      launchers: {
+        register(launcher) {
+          launcherRegistrations.set(launcher.id, launcher);
+        }
+      },
+      http: {
+        async fetch(url, init) {
+          const serializedInit = {};
+          if (init) {
+            if (init.method)
+              serializedInit.method = init.method;
+            if (init.headers) {
+              if (init.headers instanceof Headers) {
+                const obj = {};
+                init.headers.forEach((v, k) => {
+                  obj[k] = v;
+                });
+                serializedInit.headers = obj;
+              } else if (Array.isArray(init.headers)) {
+                const obj = {};
+                for (const [k, v] of init.headers)
+                  obj[k] = v;
+                serializedInit.headers = obj;
+              } else {
+                serializedInit.headers = init.headers;
+              }
+            }
+            if (init.body !== void 0 && init.body !== null) {
+              serializedInit.body = typeof init.body === "string" ? init.body : String(init.body);
+            }
+          }
+          const result = await callHost("http.fetch", {
+            url,
+            init: Object.keys(serializedInit).length > 0 ? serializedInit : void 0
+          });
+          return new Response(result.body, {
+            status: result.status,
+            statusText: result.statusText,
+            headers: result.headers
+          });
+        }
+      },
+      secrets: {
+        async resolve(secretRef) {
+          return callHost("secrets.resolve", { secretRef });
+        }
+      },
+      activity: {
+        async log(entry) {
+          await callHost("activity.log", {
+            companyId: entry.companyId,
+            message: entry.message,
+            entityType: entry.entityType,
+            entityId: entry.entityId,
+            metadata: entry.metadata
+          });
+        }
+      },
+      state: {
+        async get(input) {
+          return callHost("state.get", {
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            namespace: input.namespace,
+            stateKey: input.stateKey
+          });
+        },
+        async set(input, value) {
+          await callHost("state.set", {
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            namespace: input.namespace,
+            stateKey: input.stateKey,
+            value
+          });
+        },
+        async delete(input) {
+          await callHost("state.delete", {
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            namespace: input.namespace,
+            stateKey: input.stateKey
+          });
+        }
+      },
+      entities: {
+        async upsert(input) {
+          return callHost("entities.upsert", {
+            entityType: input.entityType,
+            scopeKind: input.scopeKind,
+            scopeId: input.scopeId,
+            externalId: input.externalId,
+            title: input.title,
+            status: input.status,
+            data: input.data
+          });
+        },
+        async list(query) {
+          return callHost("entities.list", {
+            entityType: query.entityType,
+            scopeKind: query.scopeKind,
+            scopeId: query.scopeId,
+            externalId: query.externalId,
+            limit: query.limit,
+            offset: query.offset
+          });
+        }
+      },
+      projects: {
+        async list(input) {
+          return callHost("projects.list", {
+            companyId: input.companyId,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(projectId, companyId) {
+          return callHost("projects.get", { projectId, companyId });
+        },
+        async listWorkspaces(projectId, companyId) {
+          return callHost("projects.listWorkspaces", { projectId, companyId });
+        },
+        async getPrimaryWorkspace(projectId, companyId) {
+          return callHost("projects.getPrimaryWorkspace", { projectId, companyId });
+        },
+        async getWorkspaceForIssue(issueId, companyId) {
+          return callHost("projects.getWorkspaceForIssue", { issueId, companyId });
+        }
+      },
+      companies: {
+        async list(input) {
+          return callHost("companies.list", {
+            limit: input?.limit,
+            offset: input?.offset
+          });
+        },
+        async get(companyId) {
+          return callHost("companies.get", { companyId });
+        }
+      },
+      issues: {
+        async list(input) {
+          return callHost("issues.list", {
+            companyId: input.companyId,
+            projectId: input.projectId,
+            assigneeAgentId: input.assigneeAgentId,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(issueId, companyId) {
+          return callHost("issues.get", { issueId, companyId });
+        },
+        async create(input) {
+          return callHost("issues.create", {
+            companyId: input.companyId,
+            projectId: input.projectId,
+            goalId: input.goalId,
+            parentId: input.parentId,
+            title: input.title,
+            description: input.description,
+            priority: input.priority,
+            assigneeAgentId: input.assigneeAgentId
+          });
+        },
+        async update(issueId, patch, companyId) {
+          return callHost("issues.update", {
+            issueId,
+            patch,
+            companyId
+          });
+        },
+        async listComments(issueId, companyId) {
+          return callHost("issues.listComments", { issueId, companyId });
+        },
+        async createComment(issueId, body, companyId) {
+          return callHost("issues.createComment", { issueId, body, companyId });
+        },
+        documents: {
+          async list(issueId, companyId) {
+            return callHost("issues.documents.list", { issueId, companyId });
+          },
+          async get(issueId, key, companyId) {
+            return callHost("issues.documents.get", { issueId, key, companyId });
+          },
+          async upsert(input) {
+            return callHost("issues.documents.upsert", {
+              issueId: input.issueId,
+              key: input.key,
+              body: input.body,
+              companyId: input.companyId,
+              title: input.title,
+              format: input.format,
+              changeSummary: input.changeSummary
+            });
+          },
+          async delete(issueId, key, companyId) {
+            return callHost("issues.documents.delete", { issueId, key, companyId });
+          }
+        }
+      },
+      agents: {
+        async list(input) {
+          return callHost("agents.list", {
+            companyId: input.companyId,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(agentId, companyId) {
+          return callHost("agents.get", { agentId, companyId });
+        },
+        async pause(agentId, companyId) {
+          return callHost("agents.pause", { agentId, companyId });
+        },
+        async resume(agentId, companyId) {
+          return callHost("agents.resume", { agentId, companyId });
+        },
+        async invoke(agentId, companyId, opts) {
+          return callHost("agents.invoke", { agentId, companyId, prompt: opts.prompt, reason: opts.reason });
+        },
+        sessions: {
+          async create(agentId, companyId, opts) {
+            return callHost("agents.sessions.create", {
+              agentId,
+              companyId,
+              taskKey: opts?.taskKey,
+              reason: opts?.reason
+            });
+          },
+          async list(agentId, companyId) {
+            return callHost("agents.sessions.list", { agentId, companyId });
+          },
+          async sendMessage(sessionId, companyId, opts) {
+            if (opts.onEvent) {
+              sessionEventCallbacks.set(sessionId, opts.onEvent);
+            }
+            try {
+              return await callHost("agents.sessions.sendMessage", {
+                sessionId,
+                companyId,
+                prompt: opts.prompt,
+                reason: opts.reason
+              });
+            } catch (err) {
+              sessionEventCallbacks.delete(sessionId);
+              throw err;
+            }
+          },
+          async close(sessionId, companyId) {
+            sessionEventCallbacks.delete(sessionId);
+            await callHost("agents.sessions.close", { sessionId, companyId });
+          }
+        }
+      },
+      goals: {
+        async list(input) {
+          return callHost("goals.list", {
+            companyId: input.companyId,
+            level: input.level,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset
+          });
+        },
+        async get(goalId, companyId) {
+          return callHost("goals.get", { goalId, companyId });
+        },
+        async create(input) {
+          return callHost("goals.create", {
+            companyId: input.companyId,
+            title: input.title,
+            description: input.description,
+            level: input.level,
+            status: input.status,
+            parentId: input.parentId,
+            ownerAgentId: input.ownerAgentId
+          });
+        },
+        async update(goalId, patch, companyId) {
+          return callHost("goals.update", {
+            goalId,
+            patch,
+            companyId
+          });
+        }
+      },
+      data: {
+        register(key, handler) {
+          dataHandlers.set(key, handler);
+        }
+      },
+      actions: {
+        register(key, handler) {
+          actionHandlers.set(key, handler);
+        }
+      },
+      streams: /* @__PURE__ */ (() => {
+        const channelCompanyMap = /* @__PURE__ */ new Map();
+        return {
+          open(channel, companyId) {
+            channelCompanyMap.set(channel, companyId);
+            notifyHost("streams.open", { channel, companyId });
+          },
+          emit(channel, event) {
+            const companyId = channelCompanyMap.get(channel) ?? "";
+            notifyHost("streams.emit", { channel, companyId, event });
+          },
+          close(channel) {
+            const companyId = channelCompanyMap.get(channel) ?? "";
+            channelCompanyMap.delete(channel);
+            notifyHost("streams.close", { channel, companyId });
+          }
+        };
+      })(),
+      tools: {
+        register(name, declaration, fn) {
+          toolHandlers.set(name, { declaration, fn });
+        }
+      },
+      metrics: {
+        async write(name, value, tags) {
+          await callHost("metrics.write", { name, value, tags });
+        }
+      },
+      logger: {
+        info(message, meta) {
+          notifyHost("log", { level: "info", message, meta });
+        },
+        warn(message, meta) {
+          notifyHost("log", { level: "warn", message, meta });
+        },
+        error(message, meta) {
+          notifyHost("log", { level: "error", message, meta });
+        },
+        debug(message, meta) {
+          notifyHost("log", { level: "debug", message, meta });
+        }
+      }
+    };
+  }
+  const ctx = buildContext();
+  async function handleHostRequest(request) {
+    const { id, method, params } = request;
+    try {
+      const result = await dispatchMethod(method, params);
+      sendMessage(createSuccessResponse(id, result ?? null));
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const errorCode = typeof err?.code === "number" ? err.code : PLUGIN_RPC_ERROR_CODES.WORKER_ERROR;
+      sendMessage(createErrorResponse(id, errorCode, errorMessage));
+    }
+  }
+  async function dispatchMethod(method, params) {
+    switch (method) {
+      case "initialize":
+        return handleInitialize(params);
+      case "health":
+        return handleHealth();
+      case "shutdown":
+        return handleShutdown();
+      case "validateConfig":
+        return handleValidateConfig(params);
+      case "configChanged":
+        return handleConfigChanged(params);
+      case "onEvent":
+        return handleOnEvent(params);
+      case "runJob":
+        return handleRunJob(params);
+      case "handleWebhook":
+        return handleWebhook(params);
+      case "getData":
+        return handleGetData(params);
+      case "performAction":
+        return handlePerformAction(params);
+      case "executeTool":
+        return handleExecuteTool(params);
+      default:
+        throw Object.assign(new Error(`Unknown method: ${method}`), { code: JSONRPC_ERROR_CODES.METHOD_NOT_FOUND });
+    }
+  }
+  async function handleInitialize(params) {
+    if (initialized) {
+      throw new Error("Worker already initialized");
+    }
+    manifest = params.manifest;
+    currentConfig = params.config;
+    await plugin2.definition.setup(ctx);
+    initialized = true;
+    const supportedMethods = [];
+    if (plugin2.definition.onValidateConfig)
+      supportedMethods.push("validateConfig");
+    if (plugin2.definition.onConfigChanged)
+      supportedMethods.push("configChanged");
+    if (plugin2.definition.onHealth)
+      supportedMethods.push("health");
+    if (plugin2.definition.onShutdown)
+      supportedMethods.push("shutdown");
+    return { ok: true, supportedMethods };
+  }
+  async function handleHealth() {
+    if (plugin2.definition.onHealth) {
+      return plugin2.definition.onHealth();
+    }
+    return { status: "ok" };
+  }
+  async function handleShutdown() {
+    if (plugin2.definition.onShutdown) {
+      await plugin2.definition.onShutdown();
+    }
+    setImmediate(() => {
+      cleanup();
+      if (!options.stdin && !options.stdout) {
+        process.exit(0);
+      }
+    });
+  }
+  async function handleValidateConfig(params) {
+    if (!plugin2.definition.onValidateConfig) {
+      throw Object.assign(new Error("validateConfig is not implemented by this plugin"), { code: PLUGIN_RPC_ERROR_CODES.METHOD_NOT_IMPLEMENTED });
+    }
+    return plugin2.definition.onValidateConfig(params.config);
+  }
+  async function handleConfigChanged(params) {
+    currentConfig = params.config;
+    if (plugin2.definition.onConfigChanged) {
+      await plugin2.definition.onConfigChanged(params.config);
+    }
+  }
+  async function handleOnEvent(params) {
+    const event = params.event;
+    for (const registration of eventHandlers) {
+      const exactMatch = registration.name === event.eventType;
+      const wildcardPluginAll = registration.name === "plugin.*" && event.eventType.startsWith("plugin.");
+      const wildcardPluginOne = registration.name.endsWith(".*") && event.eventType.startsWith(registration.name.slice(0, -1));
+      if (!exactMatch && !wildcardPluginAll && !wildcardPluginOne)
+        continue;
+      if (registration.filter && !allowsEvent(registration.filter, event))
+        continue;
+      try {
+        await registration.fn(event);
+      } catch (err) {
+        notifyHost("log", {
+          level: "error",
+          message: `Event handler for "${registration.name}" failed: ${err instanceof Error ? err.message : String(err)}`,
+          meta: { eventType: event.eventType, stack: err instanceof Error ? err.stack : void 0 }
+        });
+      }
+    }
+  }
+  async function handleRunJob(params) {
+    const handler = jobHandlers.get(params.job.jobKey);
+    if (!handler) {
+      throw new Error(`No handler registered for job "${params.job.jobKey}"`);
+    }
+    await handler(params.job);
+  }
+  async function handleWebhook(params) {
+    if (!plugin2.definition.onWebhook) {
+      throw Object.assign(new Error("handleWebhook is not implemented by this plugin"), { code: PLUGIN_RPC_ERROR_CODES.METHOD_NOT_IMPLEMENTED });
+    }
+    await plugin2.definition.onWebhook(params);
+  }
+  async function handleGetData(params) {
+    const handler = dataHandlers.get(params.key);
+    if (!handler) {
+      throw new Error(`No data handler registered for key "${params.key}"`);
+    }
+    return handler(params.renderEnvironment === void 0 ? params.params : { ...params.params, renderEnvironment: params.renderEnvironment });
+  }
+  async function handlePerformAction(params) {
+    const handler = actionHandlers.get(params.key);
+    if (!handler) {
+      throw new Error(`No action handler registered for key "${params.key}"`);
+    }
+    return handler(params.renderEnvironment === void 0 ? params.params : { ...params.params, renderEnvironment: params.renderEnvironment });
+  }
+  async function handleExecuteTool(params) {
+    const entry = toolHandlers.get(params.toolName);
+    if (!entry) {
+      throw new Error(`No tool handler registered for "${params.toolName}"`);
+    }
+    return entry.fn(params.parameters, params.runContext);
+  }
+  function allowsEvent(filter, event) {
+    const payload = event.payload;
+    if (filter.companyId !== void 0) {
+      const companyId = event.companyId ?? String(payload?.companyId ?? "");
+      if (companyId !== filter.companyId)
+        return false;
+    }
+    if (filter.projectId !== void 0) {
+      const projectId = event.entityType === "project" ? event.entityId : String(payload?.projectId ?? "");
+      if (projectId !== filter.projectId)
+        return false;
+    }
+    if (filter.agentId !== void 0) {
+      const agentId = event.entityType === "agent" ? event.entityId : String(payload?.agentId ?? "");
+      if (agentId !== filter.agentId)
+        return false;
+    }
+    return true;
+  }
+  function handleHostResponse(response) {
+    const id = response.id;
+    if (id === null || id === void 0)
+      return;
+    const pending = pendingRequests.get(id);
+    if (!pending)
+      return;
+    clearTimeout(pending.timer);
+    pendingRequests.delete(id);
+    pending.resolve(response);
+  }
+  function handleLine(line) {
+    if (!line.trim())
+      return;
+    let message;
+    try {
+      message = parseMessage(line);
+    } catch (err) {
+      if (err instanceof JsonRpcParseError) {
+        sendMessage(createErrorResponse(null, JSONRPC_ERROR_CODES.PARSE_ERROR, `Parse error: ${err.message}`));
+      }
+      return;
+    }
+    if (isJsonRpcResponse(message)) {
+      handleHostResponse(message);
+    } else if (isJsonRpcRequest(message)) {
+      handleHostRequest(message).catch((err) => {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const errorCode = err?.code ?? PLUGIN_RPC_ERROR_CODES.WORKER_ERROR;
+        try {
+          sendMessage(createErrorResponse(message.id, typeof errorCode === "number" ? errorCode : PLUGIN_RPC_ERROR_CODES.WORKER_ERROR, errorMessage));
+        } catch {
+        }
+      });
+    } else if (isJsonRpcNotification(message)) {
+      const notif = message;
+      if (notif.method === "agents.sessions.event" && notif.params) {
+        const event = notif.params;
+        const cb = sessionEventCallbacks.get(event.sessionId);
+        if (cb)
+          cb(event);
+      } else if (notif.method === "onEvent" && notif.params) {
+        handleOnEvent(notif.params).catch((err) => {
+          notifyHost("log", {
+            level: "error",
+            message: `Failed to handle event notification: ${err instanceof Error ? err.message : String(err)}`
+          });
+        });
+      }
+    }
+  }
+  function cleanup() {
+    running = false;
+    if (readline) {
+      readline.close();
+      readline = null;
+    }
+    for (const [id, pending] of pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.resolve(createErrorResponse(id, PLUGIN_RPC_ERROR_CODES.WORKER_UNAVAILABLE, "Worker RPC host is shutting down"));
+    }
+    pendingRequests.clear();
+    sessionEventCallbacks.clear();
+  }
+  let readline = createInterface({
+    input: stdinStream,
+    crlfDelay: Infinity
+  });
+  readline.on("line", handleLine);
+  readline.on("close", () => {
+    if (running) {
+      cleanup();
+      if (!options.stdin && !options.stdout) {
+        process.exit(0);
+      }
+    }
+  });
+  if (!options.stdin && !options.stdout) {
+    process.on("uncaughtException", (err) => {
+      notifyHost("log", {
+        level: "error",
+        message: `Uncaught exception: ${err.message}`,
+        meta: { stack: err.stack }
+      });
+      setTimeout(() => process.exit(1), 100);
+    });
+    process.on("unhandledRejection", (reason) => {
+      const message = reason instanceof Error ? reason.message : String(reason);
+      const stack = reason instanceof Error ? reason.stack : void 0;
+      notifyHost("log", {
+        level: "error",
+        message: `Unhandled rejection: ${message}`,
+        meta: { stack }
+      });
+    });
+  }
+  return {
+    get running() {
+      return running;
+    },
+    stop() {
+      cleanup();
+    }
+  };
+}
+
+// src/constants.ts
+var JOB_KEYS = {
+  discoveryRun: "discovery-run",
+  authorityDecay: "authority-decay",
+  complianceCheck: "compliance-check",
+  corpusRetention: "corpus-retention"
+};
+var TOOL_NAMES = {
+  searchCorpus: "search-corpus",
+  getToday: "get-today",
+  getAuthorities: "get-authorities",
+  suggestHandles: "suggest-handles",
+  trackHandle: "track-handle"
+};
+var ENTITY_TYPES = {
+  tweet: "tweet",
+  handle: "handle"
+};
+var STATE_KEYS = {
+  corpusPrefix: "corpus:",
+  lastDiscoveryRun: "last-discovery-run",
+  pipelineStats: "pipeline-stats"
+};
+var EVENT_NAMES = {
+  corpusUpdated: "corpus.updated",
+  handlePromoted: "handle.promoted",
+  gapIdentified: "gap.identified"
+};
+var DEFAULT_CONFIG = {
+  company_id: "",
+  xai_api_key_ref: "XAI_API_KEY",
+  x_api_bearer_ref: "BEARER_TOKEN",
+  semantic_topics: [
+    "institutional investors discussing market structure reform",
+    "fintech companies disrupting traditional trading",
+    "SEC regulatory changes affecting options trading",
+    "algorithmic trading and quantitative strategies",
+    "venture capital investing in financial infrastructure",
+    "PEAK6",
+    "options market making technology",
+    "Chicago trading community news"
+  ],
+  keyword_searches: [
+    '"PEAK6 Investments" OR "PEAK6" trading fintech',
+    "fintech and trading technology",
+    "market structure and regulation",
+    "options trading strategies and platforms"
+  ],
+  content_pillars: [
+    "market structure & regulation",
+    "fintech & trading technology",
+    "venture capital & investment",
+    "Chicago business ecosystem",
+    "company culture & talent"
+  ],
+  scoring_weights: {
+    relevance: 0.45,
+    recency: 0.25,
+    engagement: 0.3
+  },
+  engagement_sub_weights: {
+    likes: 0.55,
+    reposts: 0.25,
+    replies: 0.15,
+    quotes: 0.05
+  },
+  max_corpus_size: 200,
+  dedup_threshold: 0.7,
+  authority_boost: 0.15,
+  authority_lists: {
+    market_structure: {
+      description: "Market structure, regulation, SEC reform, options trading",
+      handles: [
+        "LizAnnSonders",
+        "matt_levine",
+        "unusual_whales",
+        "CMEGroup",
+        "CBOE",
+        "OptionsHawk",
+        "InvestorDenis"
+      ],
+      last_reviewed: "2026-03-29"
+    },
+    fintech: {
+      description: "Fintech, trading technology, AI in finance",
+      handles: [
+        "twifintech",
+        "IBSIntelligence",
+        "privy_io",
+        "i_Know_First",
+        "fintech_germany",
+        "venture_radar"
+      ],
+      last_reviewed: "2026-03-29"
+    },
+    venture_capital: {
+      description: "Venture capital investing in financial infrastructure",
+      handles: [
+        "a16z",
+        "FundersVC"
+      ],
+      last_reviewed: "2026-03-29"
+    },
+    chicago_trading: {
+      description: "Chicago trading community, prop firms, PEAK6 ecosystem",
+      handles: [
+        "CBOE",
+        "CMEGroup",
+        "boogeymantradez",
+        "adealafia"
+      ],
+      last_reviewed: "2026-03-29"
+    }
+  },
+  global_excluded: ["elonmusk", "openai", "google", "microsoft"],
+  authority_promotion_policy: {
+    auto_promote_threshold: {
+      min_appearances: 7,
+      min_avg_relevance: 0.8,
+      min_mutual_overlap: 3
+    },
+    candidate_threshold: {
+      min_appearances: 5,
+      min_avg_relevance: 0.7,
+      min_mutual_overlap: 2
+    },
+    tracking_window_days: 14
+  },
+  corpus_retention_days: 90
+};
+
+// src/pipeline/xai-client.ts
+var XAI_RESPONSES_URL = "https://api.x.ai/v1/responses";
+var XAI_MODEL = "grok-4-fast-reasoning";
+var TWEET_ID_PATTERN = /x\.com\/(?:i\/status|[^/]+\/status)\/(\d+)/;
+function extractTweetIds(annotations) {
+  const ids = [];
+  for (const ann of annotations) {
+    if (ann.type !== "url_citation" || !ann.url) continue;
+    const match = TWEET_ID_PATTERN.exec(ann.url);
+    if (match?.[1]) {
+      ids.push(match[1]);
+    }
+  }
+  return ids;
+}
+function deduplicateIds(idArrays) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ids of idArrays) {
+    for (const id of ids) {
+      if (!seen.has(id)) {
+        seen.add(id);
+        result.push(id);
+      }
+    }
+  }
+  return result;
+}
+async function xaiSearch(http, secrets, logger, apiKeyRef, options) {
+  const apiKey = await secrets.resolve(apiKeyRef);
+  const tool = {
+    type: "x_search",
+    from_date: options.fromDate,
+    to_date: options.toDate
+  };
+  if (options.allowedHandles?.length) {
+    tool.allowed_x_handles = options.allowedHandles.slice(0, 10);
+  }
+  if (options.excludedHandles?.length) {
+    tool.excluded_x_handles = options.excludedHandles.slice(0, 10);
+  }
+  const body = {
+    model: XAI_MODEL,
+    input: [{ role: "user", content: options.query }],
+    tools: [tool],
+    inline_citations: true
+  };
+  logger.debug("xAI search request", { query: options.query, handles: options.allowedHandles });
+  const response = await globalThis.fetch(XAI_RESPONSES_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`xAI API error ${response.status}: ${errorText}`);
+  }
+  const data = await response.json();
+  let synthesisText = "";
+  const allAnnotations = [];
+  for (const output of data.output) {
+    if (output.type === "message" && output.content) {
+      for (const content of output.content) {
+        if (content.type === "output_text") {
+          if (content.text) synthesisText += content.text + "\n";
+          if (content.annotations) allAnnotations.push(...content.annotations);
+        }
+      }
+    }
+  }
+  const tweetIds = extractTweetIds(allAnnotations);
+  logger.debug("xAI search result", {
+    tweetIdsFound: tweetIds.length,
+    annotationsCount: allAnnotations.length,
+    tokensUsed: data.usage?.total_tokens ?? 0,
+    firstAnnotationUrl: allAnnotations[0]?.url ?? "NONE"
+  });
+  return {
+    tweetIds,
+    synthesisText: synthesisText.trim(),
+    annotations: allAnnotations,
+    tokensUsed: data.usage?.total_tokens ?? 0,
+    costUsdTicks: data.usage?.cost_in_usd_ticks ?? 0
+  };
+}
+
+// src/pipeline/x-api-client.ts
+var X_API_BASE = "https://api.x.com/2";
+var TWEET_FIELDS = "text,author_id,created_at,public_metrics,entities";
+var USER_FIELDS = "username,name,verified_type,public_metrics";
+var EXPANSIONS = "author_id";
+var BATCH_SIZE = 100;
+async function batchLookupTweets(http, secrets, logger, bearerRef, tweetIds, source) {
+  if (tweetIds.length === 0) return [];
+  const bearerToken = await secrets.resolve(bearerRef);
+  const results = [];
+  for (let i = 0; i < tweetIds.length; i += BATCH_SIZE) {
+    const batch = tweetIds.slice(i, i + BATCH_SIZE);
+    const url = `${X_API_BASE}/tweets?ids=${batch.join(",")}&tweet.fields=${TWEET_FIELDS}&expansions=${EXPANSIONS}&user.fields=${USER_FIELDS}`;
+    logger.debug("X API v2 batch lookup", { batchSize: batch.length, offset: i });
+    const response = await http.fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${bearerToken}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.warn("X API v2 error", { status: response.status, error: errorText });
+      continue;
+    }
+    const data = await response.json();
+    if (data.errors?.length) {
+      logger.debug("X API v2 partial errors", {
+        errors: data.errors.map((e) => `${e.value}: ${e.title}`)
+      });
+    }
+    const userMap = /* @__PURE__ */ new Map();
+    if (data.includes?.users) {
+      for (const user of data.includes.users) {
+        userMap.set(user.id, user);
+      }
+    }
+    if (data.data) {
+      for (const tweet of data.data) {
+        const author = userMap.get(tweet.author_id);
+        results.push(mapToEnrichedTweet(tweet, author, source));
+      }
+    }
+  }
+  return results;
+}
+function mapToEnrichedTweet(tweet, author, source) {
+  return {
+    tweet_id: tweet.id,
+    text: tweet.text,
+    author_id: tweet.author_id,
+    author_username: author?.username ?? "unknown",
+    author_name: author?.name ?? "Unknown",
+    author_verified_type: author?.verified_type,
+    author_followers_count: author?.public_metrics?.followers_count ?? 0,
+    created_at: tweet.created_at,
+    metrics: tweet.public_metrics,
+    entities: tweet.entities,
+    source
+  };
+}
+async function verifyTweetExists(http, secrets, bearerRef, tweetId) {
+  const bearerToken = await secrets.resolve(bearerRef);
+  const url = `${X_API_BASE}/tweets?ids=${tweetId}&tweet.fields=id`;
+  const response = await http.fetch(url, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${bearerToken}` }
+  });
+  if (!response.ok) return false;
+  const data = await response.json();
+  return (data.data?.length ?? 0) > 0;
+}
+
+// src/pipeline/scoring.ts
+function trigrams(text) {
+  const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+  const set = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= normalized.length - 3; i++) {
+    set.add(normalized.substring(i, i + 3));
+  }
+  return set;
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 1;
+  let intersection = 0;
+  for (const item of a) {
+    if (b.has(item)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function deduplicateTweets(tweets, threshold) {
+  const sorted = [...tweets].sort((a, b) => b.score - a.score);
+  const kept = [];
+  const keptTrigrams = [];
+  for (const tweet of sorted) {
+    const tweetTri = trigrams(tweet.text);
+    let isDuplicate = false;
+    for (const existingTri of keptTrigrams) {
+      if (jaccardSimilarity(tweetTri, existingTri) >= threshold) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) {
+      kept.push(tweet);
+      keptTrigrams.push(tweetTri);
+    }
+  }
+  return kept;
+}
+function logNormalize(value) {
+  return Math.log1p(value) / Math.log1p(1e6);
+}
+function computeEngagementScore(metrics, subWeights) {
+  const likes = logNormalize(metrics.like_count) * subWeights.likes;
+  const reposts = logNormalize(metrics.retweet_count) * subWeights.reposts;
+  const replies = logNormalize(metrics.reply_count) * subWeights.replies;
+  const quotes = logNormalize(metrics.quote_count) * subWeights.quotes;
+  return likes + reposts + replies + quotes;
+}
+function computeRecencyScore(createdAt, now) {
+  const created = new Date(createdAt);
+  const ageHours = (now.getTime() - created.getTime()) / (1e3 * 60 * 60);
+  if (ageHours <= 0) return 1;
+  if (ageHours <= 6) return 1;
+  if (ageHours <= 24) return 0.9;
+  if (ageHours <= 48) return 0.7;
+  if (ageHours <= 168) return 0.4;
+  return 0.1;
+}
+function computeRelevanceScore(tweet, topics) {
+  const textLower = tweet.text.toLowerCase();
+  let matchCount = 0;
+  for (const topic of topics) {
+    const words = topic.toLowerCase().split(/\s+/);
+    const wordMatches = words.filter((w) => textLower.includes(w)).length;
+    if (wordMatches >= Math.ceil(words.length * 0.5)) {
+      matchCount++;
+    }
+  }
+  const topicBoost = Math.min(matchCount * 0.1, 0.5);
+  return Math.min(0.5 + topicBoost, 1);
+}
+function scoreTweets(tweets, weights, subWeights, authorityBoost, authorityHandles, authorityByDomain, topics, now) {
+  const scoreTime = now ?? /* @__PURE__ */ new Date();
+  return tweets.map((tweet) => {
+    const relevance = computeRelevanceScore(tweet, topics);
+    const recency = computeRecencyScore(tweet.created_at, scoreTime);
+    const engagement = computeEngagementScore(tweet.metrics, subWeights);
+    const isAuthority = authorityHandles.has(tweet.author_username.toLowerCase());
+    const authorityDomains = [];
+    for (const [domain, handles] of authorityByDomain) {
+      if (handles.some((h) => h.toLowerCase() === tweet.author_username.toLowerCase())) {
+        authorityDomains.push(domain);
+      }
+    }
+    const score = relevance * weights.relevance + (isAuthority ? authorityBoost : 0) + recency * weights.recency + engagement * weights.engagement;
+    return {
+      ...tweet,
+      score: Math.min(score, 1),
+      relevance_score: relevance,
+      recency_score: recency,
+      engagement_score: engagement,
+      is_authority: isAuthority,
+      authority_domains: authorityDomains
+    };
+  });
+}
+
+// src/pipeline/queries.ts
+function buildOpenQueries(topics, keywords, dateStr) {
+  const queries = [];
+  for (const topic of topics) {
+    queries.push({
+      text: `What are people saying about ${topic} today (${dateStr})?`,
+      topic,
+      phase: "open"
+    });
+  }
+  for (const keyword of keywords) {
+    queries.push({
+      text: `What are people saying about ${keyword} today (${dateStr})?`,
+      topic: keyword,
+      phase: "open"
+    });
+  }
+  return queries;
+}
+function buildFocusedQueries(topics, authorityByDomain, activeHandles, dateStr) {
+  const queries = [];
+  const sortedActive = [...activeHandles.entries()].sort(([, a], [, b]) => b.engagement + b.relevance - (a.engagement + a.relevance)).map(([handle]) => handle);
+  for (const topic of topics) {
+    const domainHandles = findBestDomainHandles(topic, authorityByDomain);
+    const authoritySlice = domainHandles.slice(0, 5);
+    const activeSlice = sortedActive.filter((h) => !authoritySlice.includes(h)).slice(0, 5);
+    const combinedHandles = [...authoritySlice, ...activeSlice].slice(0, 10);
+    if (combinedHandles.length === 0) continue;
+    queries.push({
+      text: `What are these accounts saying about ${topic} today (${dateStr})?`,
+      topic,
+      phase: "focused",
+      handles: combinedHandles
+    });
+  }
+  for (const [domain, handles] of authorityByDomain) {
+    if (handles.length <= 5) continue;
+    for (let offset = 5; offset < handles.length; offset += 5) {
+      const rotationSlice = handles.slice(offset, offset + 5);
+      const activeSlice = sortedActive.filter((h) => !rotationSlice.includes(h)).slice(0, 5);
+      const combinedHandles = [...rotationSlice, ...activeSlice].slice(0, 10);
+      if (combinedHandles.length === 0) continue;
+      queries.push({
+        text: `What are these accounts saying about ${domain} today (${dateStr})?`,
+        topic: domain,
+        phase: "focused",
+        handles: combinedHandles
+      });
+    }
+  }
+  return queries;
+}
+function findBestDomainHandles(topic, authorityByDomain) {
+  const topicLower = topic.toLowerCase();
+  let bestMatch = "";
+  let bestScore = 0;
+  for (const [domain] of authorityByDomain) {
+    const domainWords = domain.toLowerCase().split(/[_\s]+/);
+    const matchCount = domainWords.filter((w) => topicLower.includes(w)).length;
+    if (matchCount > bestScore) {
+      bestScore = matchCount;
+      bestMatch = domain;
+    }
+  }
+  return bestMatch ? authorityByDomain.get(bestMatch) ?? [] : [];
+}
+
+// src/pipeline/handles.ts
+async function updateHandleTracker(entities, logger, updates, existingAuthority) {
+  let discovered = 0;
+  let updated = 0;
+  for (const update of updates) {
+    const usernameLower = update.username.toLowerCase();
+    if (existingAuthority.has(usernameLower)) continue;
+    const existing = await entities.list({
+      entityType: ENTITY_TYPES.handle,
+      externalId: usernameLower,
+      limit: 1
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (existing.length > 0) {
+      const record = existing[0];
+      const data = record.data;
+      const newAppearances = data.appearances + 1;
+      const newAvgRelevance = (data.avg_relevance * data.appearances + update.relevance) / newAppearances;
+      const newDomains = [.../* @__PURE__ */ new Set([...data.domains, ...update.domains])];
+      const newSampleIds = update.tweetId ? [.../* @__PURE__ */ new Set([...data.sample_tweet_ids, update.tweetId])].slice(-10) : data.sample_tweet_ids;
+      const newFollowedBy = [.../* @__PURE__ */ new Set([...data.followed_by_existing, ...update.followedByExisting])];
+      await entities.upsert({
+        entityType: ENTITY_TYPES.handle,
+        scopeKind: "instance",
+        externalId: usernameLower,
+        title: usernameLower,
+        status: record.status ?? "discovered",
+        data: {
+          ...data,
+          last_seen: now,
+          appearances: newAppearances,
+          avg_relevance: Math.round(newAvgRelevance * 1e3) / 1e3,
+          domains: newDomains,
+          followed_by_existing: newFollowedBy,
+          sample_tweet_ids: newSampleIds,
+          followers_count: update.followersCount ?? data.followers_count,
+          verified_type: update.verifiedType ?? data.verified_type,
+          x_user_id: update.userId ?? data.x_user_id
+        }
+      });
+      updated++;
+    } else {
+      const data = {
+        first_seen: now,
+        last_seen: now,
+        appearances: 1,
+        avg_relevance: update.relevance,
+        domains: update.domains,
+        followed_by_existing: update.followedByExisting,
+        x_user_id: update.userId,
+        followers_count: update.followersCount ?? 0,
+        verified_type: update.verifiedType,
+        sample_tweet_ids: update.tweetId ? [update.tweetId] : [],
+        promoted_to_list: null,
+        notes: ""
+      };
+      await entities.upsert({
+        entityType: ENTITY_TYPES.handle,
+        scopeKind: "instance",
+        externalId: usernameLower,
+        title: usernameLower,
+        status: "discovered",
+        data
+      });
+      discovered++;
+    }
+  }
+  logger.info("Handle tracker updated", { discovered, updated });
+  return { discovered, updated };
+}
+async function evaluatePromotions(entities, logger, policy) {
+  const candidates = [];
+  const handles = await entities.list({
+    entityType: ENTITY_TYPES.handle,
+    limit: 200
+  });
+  for (const handle of handles) {
+    const data = handle.data;
+    const currentStatus = handle.status ?? "discovered";
+    if (currentStatus === "promoted") continue;
+    if (data.appearances >= policy.auto_promote_threshold.min_appearances && data.avg_relevance >= policy.auto_promote_threshold.min_avg_relevance && data.followed_by_existing.length >= policy.auto_promote_threshold.min_mutual_overlap) {
+      await entities.upsert({
+        entityType: ENTITY_TYPES.handle,
+        scopeKind: "instance",
+        externalId: handle.externalId,
+        title: handle.title ?? handle.externalId,
+        status: "promoted",
+        data: handle.data
+      });
+      candidates.push({ username: handle.externalId, status: "promoted", data });
+      logger.info("Handle auto-promoted", { handle: handle.externalId });
+      continue;
+    }
+    if (currentStatus === "discovered" && data.appearances >= policy.candidate_threshold.min_appearances && data.avg_relevance >= policy.candidate_threshold.min_avg_relevance) {
+      await entities.upsert({
+        entityType: ENTITY_TYPES.handle,
+        scopeKind: "instance",
+        externalId: handle.externalId,
+        title: handle.title ?? handle.externalId,
+        status: "candidate",
+        data: handle.data
+      });
+      candidates.push({ username: handle.externalId, status: "candidate", data });
+      logger.info("Handle promoted to candidate", { handle: handle.externalId });
+    }
+  }
+  return candidates;
+}
+async function decayHandles(entities, logger, trackingWindowDays) {
+  const handles = await entities.list({
+    entityType: ENTITY_TYPES.handle,
+    limit: 500
+  });
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - trackingWindowDays);
+  const cutoffStr = cutoffDate.toISOString().split("T")[0];
+  let decayed = 0;
+  for (const handle of handles) {
+    const data = handle.data;
+    const status = handle.status ?? "discovered";
+    if (status === "promoted") continue;
+    if (data.last_seen >= cutoffStr) continue;
+    if (status === "candidate") {
+      await entities.upsert({
+        entityType: ENTITY_TYPES.handle,
+        scopeKind: "instance",
+        externalId: handle.externalId,
+        title: handle.title ?? handle.externalId,
+        status: "discovered",
+        data: handle.data
+      });
+      decayed++;
+    }
+  }
+  logger.info("Handle decay complete", { decayed });
+  return decayed;
+}
+function buildHandleUpdatesFromTweets(tweets, topics, authorityByDomain) {
+  const handleMap = /* @__PURE__ */ new Map();
+  const authorityDomains = /* @__PURE__ */ new Map();
+  for (const [domain, handles] of authorityByDomain) {
+    for (const h of handles) {
+      const lower = h.toLowerCase();
+      const existing = authorityDomains.get(lower) ?? [];
+      existing.push(domain);
+      authorityDomains.set(lower, existing);
+    }
+  }
+  const topicToDomainKeys = /* @__PURE__ */ new Map();
+  for (const topic of topics) {
+    const topicLower = topic.toLowerCase();
+    const matched = [];
+    for (const [domainKey] of authorityByDomain) {
+      const keyWords = domainKey.toLowerCase().split(/[_\s]+/);
+      if (keyWords.every((w) => topicLower.includes(w))) {
+        matched.push(domainKey);
+      }
+    }
+    if (matched.length > 0) topicToDomainKeys.set(topic, matched);
+  }
+  const handleDomainKeyMap = /* @__PURE__ */ new Map();
+  for (const tweet of tweets) {
+    const username = tweet.author_username.toLowerCase();
+    const existing = handleMap.get(username);
+    const domains = [];
+    const textLower = tweet.text.toLowerCase();
+    for (const topic of topics) {
+      const words = topic.toLowerCase().split(/\s+/);
+      const wordMatches = words.filter((w) => textLower.includes(w)).length;
+      if (wordMatches >= Math.ceil(words.length * 0.5)) {
+        domains.push(topic);
+      }
+    }
+    const domainKeySet = handleDomainKeyMap.get(username) ?? /* @__PURE__ */ new Set();
+    for (const d of domains) {
+      const keys = topicToDomainKeys.get(d);
+      if (keys) for (const k of keys) domainKeySet.add(k);
+    }
+    handleDomainKeyMap.set(username, domainKeySet);
+    if (existing) {
+      existing.relevance = Math.max(existing.relevance, 0.5);
+      existing.domains = [.../* @__PURE__ */ new Set([...existing.domains, ...domains])];
+      if (tweet.tweet_id) existing.tweetId = tweet.tweet_id;
+    } else {
+      handleMap.set(username, {
+        username,
+        relevance: 0.5,
+        domains,
+        followedByExisting: [],
+        tweetId: tweet.tweet_id,
+        userId: tweet.author_id,
+        followersCount: tweet.author_followers_count,
+        verifiedType: tweet.author_verified_type
+      });
+    }
+  }
+  for (const [username, update] of handleMap) {
+    const myDomainKeys = handleDomainKeyMap.get(username);
+    if (!myDomainKeys || myDomainKeys.size === 0) continue;
+    const coOccurring = /* @__PURE__ */ new Set();
+    for (const [authHandle, authDomainKeys] of authorityDomains) {
+      if (authDomainKeys.some((d) => myDomainKeys.has(d))) {
+        coOccurring.add(authHandle);
+      }
+    }
+    update.followedByExisting = [...coOccurring];
+  }
+  return [...handleMap.values()];
+}
+
+// src/worker.ts
+async function getConfig(ctx) {
+  const raw = await ctx.config.get();
+  return { ...DEFAULT_CONFIG, ...raw };
+}
+function buildAuthorityMaps(config) {
+  const allHandles = /* @__PURE__ */ new Set();
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const [domain, list] of Object.entries(config.authority_lists)) {
+    const handles = list.handles.map((h) => h.toLowerCase());
+    byDomain.set(domain, handles);
+    for (const h of handles) allHandles.add(h);
+  }
+  return { allHandles, byDomain };
+}
+async function runDiscoveryPipeline(ctx, job) {
+  const config = await getConfig(ctx);
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const threeDaysAgo = new Date(Date.now() - 3 * 864e5).toISOString().split("T")[0];
+  const { allHandles, byDomain } = buildAuthorityMaps(config);
+  ctx.logger.info("Discovery pipeline started", { date: today, jobRunId: job.runId });
+  await ctx.metrics.write("pipeline.run.started", 1);
+  const openQueries = buildOpenQueries(config.semantic_topics, config.keyword_searches, today);
+  const openTweetIdArrays = [];
+  let totalXaiCost = 0;
+  for (const query of openQueries) {
+    try {
+      const result = await xaiSearch(
+        ctx.http,
+        ctx.secrets,
+        ctx.logger,
+        config.xai_api_key_ref,
+        { query: query.text, fromDate: threeDaysAgo, toDate: today, excludedHandles: config.global_excluded }
+      );
+      openTweetIdArrays.push(result.tweetIds);
+      totalXaiCost += result.costUsdTicks;
+    } catch (err) {
+      ctx.logger.warn("Open discovery query failed", {
+        query: query.text,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const openTweetIds = deduplicateIds(openTweetIdArrays);
+  ctx.logger.info("Stage 1 complete: open discovery", {
+    queriesRun: openQueries.length,
+    uniqueTweetIds: openTweetIds.length
+  });
+  const openTweets = await batchLookupTweets(
+    ctx.http,
+    ctx.secrets,
+    ctx.logger,
+    config.x_api_bearer_ref,
+    openTweetIds,
+    "open_discovery"
+  );
+  const activeHandles = /* @__PURE__ */ new Map();
+  for (const tweet of openTweets) {
+    const username = tweet.author_username.toLowerCase();
+    if (allHandles.has(username) || config.global_excluded.includes(username)) continue;
+    const engagement = tweet.metrics.like_count + tweet.metrics.retweet_count * 2;
+    const existing = activeHandles.get(username);
+    if (existing) {
+      existing.engagement = Math.max(existing.engagement, engagement);
+    } else {
+      activeHandles.set(username, { engagement, relevance: 0.5, domains: [] });
+    }
+  }
+  const focusedQueries = buildFocusedQueries(
+    config.semantic_topics,
+    byDomain,
+    activeHandles,
+    today
+  );
+  const focusedTweetIdArrays = [];
+  for (const query of focusedQueries) {
+    try {
+      const result = await xaiSearch(
+        ctx.http,
+        ctx.secrets,
+        ctx.logger,
+        config.xai_api_key_ref,
+        {
+          query: query.text,
+          fromDate: threeDaysAgo,
+          toDate: today,
+          allowedHandles: query.handles
+        }
+      );
+      focusedTweetIdArrays.push(result.tweetIds);
+      totalXaiCost += result.costUsdTicks;
+      if (result.tweetIds.length === 0 && query.handles?.length) {
+        ctx.logger.warn("Focused query returned 0 results \u2014 handle set may be inactive", {
+          topic: query.topic,
+          handles: query.handles
+        });
+      }
+    } catch (err) {
+      ctx.logger.warn("Focused discovery query failed", {
+        query: query.text,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const focusedTweetIds = deduplicateIds(focusedTweetIdArrays);
+  const openIdSet = new Set(openTweetIds);
+  const newFocusedIds = focusedTweetIds.filter((id) => !openIdSet.has(id));
+  ctx.logger.info("Stage 2 complete: focused discovery", {
+    queriesRun: focusedQueries.length,
+    newTweetIds: newFocusedIds.length
+  });
+  const focusedTweets = await batchLookupTweets(
+    ctx.http,
+    ctx.secrets,
+    ctx.logger,
+    config.x_api_bearer_ref,
+    newFocusedIds,
+    "focused"
+  );
+  const focusedIdSet = new Set(focusedTweetIds);
+  const allTweets = openTweets.map(
+    (t) => focusedIdSet.has(t.tweet_id) ? { ...t, source: "both" } : t
+  );
+  allTweets.push(...focusedTweets);
+  ctx.logger.info("Stage 3 complete: enrichment", { totalTweets: allTweets.length });
+  const scored = scoreTweets(
+    allTweets,
+    config.scoring_weights,
+    config.engagement_sub_weights,
+    config.authority_boost,
+    allHandles,
+    byDomain,
+    config.semantic_topics
+  );
+  const deduplicated = deduplicateTweets(scored, config.dedup_threshold);
+  const corpus = deduplicated.slice(0, config.max_corpus_size);
+  ctx.logger.info("Stage 4: scoring & dedup", {
+    scored: scored.length,
+    afterDedup: deduplicated.length,
+    finalCorpus: corpus.length
+  });
+  for (const tweet of corpus) {
+    await ctx.entities.upsert({
+      entityType: ENTITY_TYPES.tweet,
+      scopeKind: "instance",
+      externalId: tweet.tweet_id,
+      title: `@${tweet.author_username}: ${tweet.text.slice(0, 80)}`,
+      status: "active",
+      data: tweet
+    });
+  }
+  const handleUpdates = buildHandleUpdatesFromTweets(allTweets, config.semantic_topics, byDomain);
+  const handleStats = await updateHandleTracker(
+    ctx.entities,
+    ctx.logger,
+    handleUpdates,
+    allHandles
+  );
+  const promotions = await evaluatePromotions(
+    ctx.entities,
+    ctx.logger,
+    config.authority_promotion_policy
+  );
+  const summary = {
+    date: today,
+    total_tweets: corpus.length,
+    top_items: corpus.slice(0, 10),
+    by_pillar: {},
+    discovery_stats: {
+      open_queries: openQueries.length,
+      focused_queries: focusedQueries.length,
+      total_tweet_ids_extracted: openTweetIds.length + focusedTweetIds.length,
+      tweets_after_dedup: deduplicated.length,
+      tweets_after_scoring: corpus.length,
+      new_handles_discovered: handleStats.discovered,
+      handles_promoted: promotions.length,
+      xai_cost_estimate: totalXaiCost / 1e9,
+      x_api_cost_estimate: allTweets.length * 0.01
+    },
+    generated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await ctx.state.set(
+    { scopeKind: "instance", stateKey: `${STATE_KEYS.corpusPrefix}${today}` },
+    summary
+  );
+  await ctx.state.set(
+    { scopeKind: "instance", stateKey: STATE_KEYS.lastDiscoveryRun },
+    { date: today, corpusSize: corpus.length, generatedAt: summary.generated_at }
+  );
+  await ctx.events.emit(EVENT_NAMES.corpusUpdated, config.company_id, {
+    date: today,
+    corpusSize: corpus.length,
+    topScore: corpus[0]?.score ?? 0
+  });
+  for (const promo of promotions) {
+    if (promo.status === "promoted") {
+      await ctx.events.emit(EVENT_NAMES.handlePromoted, config.company_id, {
+        handle: promo.username,
+        status: promo.status,
+        appearances: promo.data.appearances,
+        avgRelevance: promo.data.avg_relevance
+      });
+    }
+  }
+  await ctx.activity.log({
+    companyId: config.company_id,
+    message: `X Intelligence discovery complete: ${corpus.length} tweets scored, ${handleStats.discovered} new handles discovered`,
+    metadata: summary.discovery_stats
+  });
+  await ctx.metrics.write("pipeline.run.completed", 1);
+  await ctx.metrics.write("pipeline.corpus.size", corpus.length);
+  await ctx.metrics.write("pipeline.handles.discovered", handleStats.discovered);
+  await ctx.metrics.write("pipeline.cost.xai", totalXaiCost / 1e9);
+  ctx.logger.info("Discovery pipeline complete", {
+    date: today,
+    corpusSize: corpus.length,
+    totalCostEstimate: `$${(totalXaiCost / 1e9 + allTweets.length * 0.01).toFixed(2)}`
+  });
+}
+async function handleAuthorityDecay(ctx, _job) {
+  const config = await getConfig(ctx);
+  const decayed = await decayHandles(
+    ctx.entities,
+    ctx.logger,
+    config.authority_promotion_policy.tracking_window_days
+  );
+  await ctx.metrics.write("handles.decayed", decayed);
+  ctx.logger.info("Authority decay job complete", { decayed });
+}
+async function handleComplianceCheck(ctx, _job) {
+  const config = await getConfig(ctx);
+  const tweets = await ctx.entities.list({ entityType: ENTITY_TYPES.tweet, limit: 200 });
+  let removed = 0;
+  for (const tweet of tweets) {
+    const tweetId = tweet.externalId;
+    if (!tweetId) continue;
+    try {
+      const exists = await verifyTweetExists(
+        ctx.http,
+        ctx.secrets,
+        config.x_api_bearer_ref,
+        tweetId
+      );
+      if (!exists) {
+        await ctx.entities.upsert({
+          entityType: ENTITY_TYPES.tweet,
+          scopeKind: "instance",
+          externalId: tweetId,
+          title: tweet.title ?? tweetId,
+          status: "removed",
+          data: { ...tweet.data, removed_reason: "deleted_or_suspended", removed_at: (/* @__PURE__ */ new Date()).toISOString() }
+        });
+        removed++;
+      }
+    } catch {
+    }
+  }
+  await ctx.metrics.write("compliance.tweets_removed", removed);
+  ctx.logger.info("Compliance check complete", { checked: tweets.length, removed });
+}
+async function handleCorpusRetention(ctx, _job) {
+  const config = await getConfig(ctx);
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - config.corpus_retention_days);
+  const cutoffStr = cutoff.toISOString().split("T")[0];
+  const tweets = await ctx.entities.list({ entityType: ENTITY_TYPES.tweet, limit: 500 });
+  let archived = 0;
+  for (const tweet of tweets) {
+    const data = tweet.data;
+    const createdAt = typeof data.created_at === "string" ? data.created_at.split("T")[0] : null;
+    if (createdAt && createdAt < cutoffStr) {
+      await ctx.entities.upsert({
+        entityType: ENTITY_TYPES.tweet,
+        scopeKind: "instance",
+        externalId: tweet.externalId,
+        title: tweet.title ?? tweet.externalId,
+        status: "archived",
+        data: { ...tweet.data, archived_at: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+      archived++;
+    }
+  }
+  await ctx.metrics.write("retention.tweets_archived", archived);
+  ctx.logger.info("Corpus retention complete", { archived });
+}
+async function handleSearchCorpus(ctx, params, _runCtx) {
+  const p = params;
+  const query = typeof p.query === "string" ? p.query.toLowerCase() : "";
+  const date = typeof p.date === "string" ? p.date : void 0;
+  const pillar = typeof p.pillar === "string" ? p.pillar.toLowerCase() : void 0;
+  const limit = typeof p.limit === "number" ? p.limit : 20;
+  const tweets = await ctx.entities.list({
+    entityType: ENTITY_TYPES.tweet,
+    limit: 200
+  });
+  const results = [];
+  for (const tweet of tweets) {
+    if (tweet.status === "removed" || tweet.status === "archived") continue;
+    const data = tweet.data;
+    const textMatch = query ? data.text.toLowerCase().includes(query) : true;
+    const dateMatch = date ? data.created_at?.startsWith(date) ?? false : true;
+    const pillarMatch = pillar ? data.authority_domains?.some((d) => d.toLowerCase().includes(pillar)) ?? false : true;
+    if (textMatch && dateMatch && pillarMatch) {
+      results.push(data);
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  const limited = results.slice(0, limit);
+  return {
+    content: `Found ${limited.length} tweets matching "${query}"`,
+    data: limited
+  };
+}
+async function handleGetToday(ctx, params, _runCtx) {
+  const p = params;
+  const pillar = typeof p.pillar === "string" ? p.pillar : void 0;
+  const limit = typeof p.limit === "number" ? p.limit : 20;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const summary = await ctx.state.get({
+    scopeKind: "instance",
+    stateKey: `${STATE_KEYS.corpusPrefix}${today}`
+  });
+  if (!summary) {
+    return { content: "No corpus available for today. Discovery may not have run yet." };
+  }
+  let items = summary.top_items;
+  if (pillar) {
+    items = items.filter(
+      (t) => t.authority_domains?.some((d) => d.toLowerCase().includes(pillar.toLowerCase())) ?? false
+    );
+  }
+  return {
+    content: `Today's corpus: ${summary.total_tweets} tweets. Showing top ${Math.min(limit, items.length)}.`,
+    data: {
+      date: summary.date,
+      total: summary.total_tweets,
+      items: items.slice(0, limit),
+      stats: summary.discovery_stats
+    }
+  };
+}
+async function handleGetAuthorities(ctx, params, _runCtx) {
+  const p = params;
+  const listName = typeof p.list_name === "string" ? p.list_name : void 0;
+  const config = await getConfig(ctx);
+  if (listName) {
+    const list = config.authority_lists[listName];
+    if (!list) {
+      return { error: `Authority list "${listName}" not found. Available: ${Object.keys(config.authority_lists).join(", ")}` };
+    }
+    return {
+      content: `Authority list "${listName}": ${list.handles.length} handles`,
+      data: { name: listName, ...list }
+    };
+  }
+  const summary = Object.entries(config.authority_lists).map(([name, list]) => ({
+    name,
+    description: list.description,
+    handleCount: list.handles.length,
+    handles: list.handles,
+    lastReviewed: list.last_reviewed
+  }));
+  return {
+    content: `${summary.length} authority lists configured`,
+    data: summary
+  };
+}
+async function handleSuggestHandles(ctx, _params, _runCtx) {
+  const handles = await ctx.entities.list({
+    entityType: ENTITY_TYPES.handle,
+    limit: 200
+  });
+  const candidates = handles.filter((h) => h.status === "candidate" || h.status === "promoted").map((h) => {
+    const data = h.data;
+    return {
+      username: h.externalId,
+      status: h.status,
+      appearances: data.appearances,
+      avg_relevance: data.avg_relevance,
+      domains: data.domains,
+      followers_count: data.followers_count,
+      first_seen: data.first_seen,
+      last_seen: data.last_seen
+    };
+  });
+  candidates.sort((a, b) => {
+    const scoreA = (a.avg_relevance ?? 0) * (a.appearances ?? 0);
+    const scoreB = (b.avg_relevance ?? 0) * (b.appearances ?? 0);
+    return scoreB - scoreA;
+  });
+  return {
+    content: `${candidates.length} handles are candidates or recently promoted`,
+    data: candidates
+  };
+}
+async function handleTrackHandle(ctx, params, _runCtx) {
+  const p = params;
+  const handle = typeof p.handle === "string" ? p.handle.toLowerCase().replace(/^@/, "") : "";
+  const relevance = typeof p.relevance === "number" ? p.relevance : 0.5;
+  const domain = typeof p.domain === "string" ? p.domain : "";
+  if (!handle) return { error: "handle is required" };
+  if (!domain) return { error: "domain is required" };
+  const config = await getConfig(ctx);
+  const { allHandles } = buildAuthorityMaps(config);
+  await updateHandleTracker(ctx.entities, ctx.logger, [
+    { username: handle, relevance, domains: [domain], followedByExisting: [] }
+  ], allHandles);
+  return {
+    content: `Handle @${handle} tracked with relevance ${relevance} in domain "${domain}"`
+  };
+}
+var plugin = definePlugin({
+  async setup(ctx) {
+    ctx.jobs.register(JOB_KEYS.discoveryRun, (job) => runDiscoveryPipeline(ctx, job));
+    ctx.jobs.register(JOB_KEYS.authorityDecay, (job) => handleAuthorityDecay(ctx, job));
+    ctx.jobs.register(JOB_KEYS.complianceCheck, (job) => handleComplianceCheck(ctx, job));
+    ctx.jobs.register(JOB_KEYS.corpusRetention, (job) => handleCorpusRetention(ctx, job));
+    ctx.tools.register(
+      TOOL_NAMES.searchCorpus,
+      { displayName: "Search X Corpus", description: "Search the scored X intelligence corpus", parametersSchema: {} },
+      (params, runCtx) => handleSearchCorpus(ctx, params, runCtx)
+    );
+    ctx.tools.register(
+      TOOL_NAMES.getToday,
+      { displayName: "Get Today's Intelligence", description: "Get today's scored corpus", parametersSchema: {} },
+      (params, runCtx) => handleGetToday(ctx, params, runCtx)
+    );
+    ctx.tools.register(
+      TOOL_NAMES.getAuthorities,
+      { displayName: "Get Authority Handles", description: "Get authority handle lists", parametersSchema: {} },
+      (params, runCtx) => handleGetAuthorities(ctx, params, runCtx)
+    );
+    ctx.tools.register(
+      TOOL_NAMES.suggestHandles,
+      { displayName: "Suggest Handle Promotions", description: "Get promotion candidates", parametersSchema: {} },
+      (params, runCtx) => handleSuggestHandles(ctx, params, runCtx)
+    );
+    ctx.tools.register(
+      TOOL_NAMES.trackHandle,
+      { displayName: "Track Handle", description: "Record a handle appearance", parametersSchema: {} },
+      (params, runCtx) => handleTrackHandle(ctx, params, runCtx)
+    );
+    ctx.data.register("dashboard-summary", async () => {
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const summary = await ctx.state.get({
+        scopeKind: "instance",
+        stateKey: `${STATE_KEYS.corpusPrefix}${today}`
+      });
+      const lastRun = await ctx.state.get({
+        scopeKind: "instance",
+        stateKey: STATE_KEYS.lastDiscoveryRun
+      });
+      const handleCount = (await ctx.entities.list({
+        entityType: ENTITY_TYPES.handle,
+        limit: 1
+      })).length;
+      return {
+        today: summary ?? null,
+        lastRun,
+        trackedHandles: handleCount
+      };
+    });
+    ctx.data.register("corpus", async (params) => {
+      const date = typeof params.date === "string" ? params.date : (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      return await ctx.state.get({
+        scopeKind: "instance",
+        stateKey: `${STATE_KEYS.corpusPrefix}${date}`
+      });
+    });
+    ctx.data.register("plugin-config", async () => {
+      return await ctx.config.get();
+    });
+    let discoveryRunning = false;
+    ctx.actions.register("trigger-discovery", async () => {
+      if (discoveryRunning) {
+        return { message: "Discovery pipeline already running." };
+      }
+      ctx.logger.info("Manual discovery trigger requested via UI");
+      discoveryRunning = true;
+      const fakeJob = { runId: `manual-${Date.now()}`, jobKey: JOB_KEYS.discoveryRun };
+      runDiscoveryPipeline(ctx, fakeJob).catch((err) => {
+        ctx.logger.error("Manual discovery failed", { error: err instanceof Error ? err.message : String(err) });
+      }).finally(() => {
+        discoveryRunning = false;
+      });
+      return { message: "Discovery pipeline started. Check logs for progress." };
+    });
+    ctx.events.on("issue.created", async (event) => {
+      ctx.logger.debug("Issue created event received", { issueId: event.entityId });
+    });
+    ctx.logger.info("X Intelligence plugin initialized");
+  },
+  async onHealth() {
+    return { status: "ok", message: "X Intelligence plugin is running" };
+  }
+});
+var worker_default = plugin;
+runWorker(plugin, import.meta.url);
+export {
+  worker_default as default
+};
+//# sourceMappingURL=worker.js.map