opensentinel 2.1.1 → 3.1.1

package/dist/chunk-SVAPX2XN.js

@@ -0,0 +1,2441 @@
+import {
+  resolveEntity
+} from "./chunk-WRAKK6K6.js";
+import {
+  db,
+  graphEntities,
+  graphRelationships
+} from "./chunk-XKYRH4FM.js";
+import {
+  env
+} from "./chunk-ZLZKF2PM.js";
+
+// src/core/intelligence/enrichment-pipeline.ts
+import { eq as eq2, sql } from "drizzle-orm";
+
+// src/integrations/public-records/rate-limiter.ts
+var RateLimiter = class {
+  constructor(name, maxPerWindow, windowMs) {
+    this.name = name;
+    this.maxPerWindow = maxPerWindow;
+    this.windowMs = windowMs;
+    this.bufferMs = Number(env.OSINT_RATE_LIMIT_BUFFER_MS) || 200;
+  }
+  /** Timestamps (ms) of requests within the current window */
+  timestamps = [];
+  /** Global buffer added after each wait to avoid edge-of-window bursts */
+  bufferMs;
+  /**
+   * Acquire permission to make a request.
+   * Resolves immediately if within limits, otherwise waits until a slot opens.
+   */
+  async acquire() {
+    this.pruneExpired();
+    if (this.timestamps.length < this.maxPerWindow) {
+      this.timestamps.push(Date.now());
+      return;
+    }
+    const oldest = this.timestamps[0];
+    const waitMs = oldest + this.windowMs - Date.now() + this.bufferMs;
+    if (waitMs > 0) {
+      console.log(
+        `[OSINT:RateLimiter:${this.name}] Rate limit reached (${this.timestamps.length}/${this.maxPerWindow}), waiting ${waitMs}ms`
+      );
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+    }
+    this.pruneExpired();
+    this.timestamps.push(Date.now());
+  }
+  /**
+   * Number of requests remaining in the current window.
+   */
+  get remaining() {
+    this.pruneExpired();
+    return Math.max(0, this.maxPerWindow - this.timestamps.length);
+  }
+  /** Remove timestamps that have fallen outside the window */
+  pruneExpired() {
+    const cutoff = Date.now() - this.windowMs;
+    while (this.timestamps.length > 0 && this.timestamps[0] < cutoff) {
+      this.timestamps.shift();
+    }
+  }
+};
+function createRateLimiter(name, maxPerWindow, windowMs) {
+  return new RateLimiter(name, maxPerWindow, windowMs);
+}
+
+// src/integrations/public-records/fec-client.ts
+var FECClientError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "FECClientError";
+  }
+};
+var LOG_PREFIX = "[OSINT:FEC]";
+var FECClient = class {
+  baseUrl = "https://api.open.fec.gov/v1";
+  apiKey;
+  timeout;
+  maxPages;
+  rateLimiter;
+  constructor(config = {}) {
+    this.apiKey = config.apiKey ?? env.FEC_API_KEY ?? "";
+    this.timeout = config.timeout ?? 15e3;
+    this.maxPages = config.maxPages ?? 10;
+    this.rateLimiter = createRateLimiter("FEC", 1e3, 60 * 60 * 1e3);
+  }
+  // -----------------------------------------------------------------------
+  // Internal helpers
+  // -----------------------------------------------------------------------
+  async request(endpoint, params = {}) {
+    await this.rateLimiter.acquire();
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    url.searchParams.set("api_key", this.apiKey);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== "") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      console.log(`${LOG_PREFIX} GET ${endpoint}`);
+      const response = await fetch(url.toString(), {
+        headers: { Accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new FECClientError(
+          `FEC API error ${response.status}: ${response.statusText} \u2014 ${body}`,
+          response.status
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof FECClientError) throw error;
+      if (error.name === "AbortError") {
+        throw new FECClientError("FEC request timed out");
+      }
+      throw new FECClientError(
+        `FEC network error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Automatically paginate through all result pages up to maxPages.
+   */
+  async paginate(endpoint, params, extractItems) {
+    const items = [];
+    let page = 1;
+    while (page <= this.maxPages) {
+      const body = await this.request(endpoint, {
+        ...params,
+        page: String(page),
+        per_page: "100"
+      });
+      const pageItems = extractItems(body);
+      items.push(...pageItems);
+      const pagination = body.pagination;
+      if (!pagination || page >= (pagination.pages ?? 1) || pageItems.length === 0) {
+        break;
+      }
+      page++;
+    }
+    return items;
+  }
+  // -----------------------------------------------------------------------
+  // Candidates
+  // -----------------------------------------------------------------------
+  async searchCandidates(query, opts = {}) {
+    return this.paginate(
+      "/candidates/search/",
+      {
+        q: query,
+        office: opts.office,
+        state: opts.state,
+        cycle: opts.cycle,
+        sort: "name"
+      },
+      (body) => (body.results ?? []).map((r) => this.mapCandidate(r))
+    );
+  }
+  async getCandidate(candidateId) {
+    const body = await this.request(`/candidate/${candidateId}/`);
+    const results = body.results ?? [];
+    if (results.length === 0) {
+      throw new FECClientError(`Candidate ${candidateId} not found`, 404);
+    }
+    return this.mapCandidate(results[0]);
+  }
+  mapCandidate(r) {
+    return {
+      candidateId: r.candidate_id ?? "",
+      name: r.name ?? "",
+      party: r.party ?? "",
+      office: r.office ?? "",
+      state: r.state ?? "",
+      district: r.district ?? "",
+      incumbentChallenger: r.incumbent_challenge ?? "",
+      cycles: r.cycles ?? [],
+      activeThrough: r.active_through ?? null
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Committees
+  // -----------------------------------------------------------------------
+  async searchCommittees(query) {
+    return this.paginate(
+      "/committees/",
+      { q: query, sort: "name" },
+      (body) => (body.results ?? []).map((r) => this.mapCommittee(r))
+    );
+  }
+  async getCommittee(committeeId) {
+    const body = await this.request(`/committee/${committeeId}/`);
+    const results = body.results ?? [];
+    if (results.length === 0) {
+      throw new FECClientError(`Committee ${committeeId} not found`, 404);
+    }
+    return this.mapCommittee(results[0]);
+  }
+  mapCommittee(r) {
+    return {
+      committeeId: r.committee_id ?? "",
+      name: r.name ?? "",
+      designation: r.designation ?? "",
+      type: r.committee_type ?? "",
+      party: r.party ?? "",
+      state: r.state ?? "",
+      treasurerName: r.treasurer_name ?? "",
+      candidateIds: r.candidate_ids ?? [],
+      cycles: r.cycles ?? []
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Contributions (Schedule A)
+  // -----------------------------------------------------------------------
+  async getContributions(opts) {
+    const params = {
+      committee_id: opts.committeeId,
+      candidate_id: opts.candidateId,
+      contributor_name: opts.contributorName,
+      min_amount: opts.minAmount,
+      max_amount: opts.maxAmount,
+      two_year_transaction_period: opts.cycle,
+      sort: "-contribution_receipt_date"
+    };
+    return this.paginate(
+      "/schedules/schedule_a/",
+      params,
+      (body) => (body.results ?? []).map((r) => this.mapContribution(r))
+    );
+  }
+  async getDonorLookup(name, state) {
+    return this.getContributions({
+      contributorName: name,
+      ...state ? {} : {}
+    });
+  }
+  mapContribution(r) {
+    return {
+      committeeId: r.committee_id ?? "",
+      committeeName: r.committee?.name ?? r.committee_name ?? "",
+      contributorName: r.contributor_name ?? "",
+      contributorCity: r.contributor_city ?? "",
+      contributorState: r.contributor_state ?? "",
+      contributorZip: r.contributor_zip ?? "",
+      contributorEmployer: r.contributor_employer ?? "",
+      contributorOccupation: r.contributor_occupation ?? "",
+      amount: r.contribution_receipt_amount ?? 0,
+      date: r.contribution_receipt_date ?? "",
+      receiptType: r.receipt_type ?? "",
+      memoText: r.memo_text ?? "",
+      transactionId: r.transaction_id ?? ""
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Disbursements (Schedule B)
+  // -----------------------------------------------------------------------
+  async getDisbursements(committeeId, cycle) {
+    return this.paginate(
+      "/schedules/schedule_b/",
+      {
+        committee_id: committeeId,
+        two_year_transaction_period: cycle,
+        sort: "-disbursement_date"
+      },
+      (body) => (body.results ?? []).map((r) => this.mapDisbursement(r))
+    );
+  }
+  mapDisbursement(r) {
+    return {
+      committeeId: r.committee_id ?? "",
+      committeeName: r.committee?.name ?? r.committee_name ?? "",
+      recipientName: r.recipient_name ?? "",
+      recipientCity: r.recipient_city ?? "",
+      recipientState: r.recipient_state ?? "",
+      amount: r.disbursement_amount ?? 0,
+      date: r.disbursement_date ?? "",
+      description: r.disbursement_description ?? "",
+      categoryCode: r.disbursement_type ?? "",
+      memoText: r.memo_text ?? ""
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Filings
+  // -----------------------------------------------------------------------
+  async getFilings(committeeId) {
+    return this.paginate(
+      "/committee/${committeeId}/filings/".replace(
+        "${committeeId}",
+        committeeId
+      ),
+      { sort: "-receipt_date" },
+      (body) => (body.results ?? []).map((r) => this.mapFiling(r))
+    );
+  }
+  mapFiling(r) {
+    return {
+      filingId: r.filing_id ?? 0,
+      committeeId: r.committee_id ?? "",
+      committeeName: r.committee_name ?? "",
+      formType: r.form_type ?? "",
+      reportType: r.report_type ?? "",
+      reportYear: r.report_year ?? 0,
+      coverageStartDate: r.coverage_start_date ?? "",
+      coverageEndDate: r.coverage_end_date ?? "",
+      totalReceipts: r.total_receipts ?? 0,
+      totalDisbursements: r.total_disbursements ?? 0,
+      cashOnHandEnd: r.cash_on_hand_end_period ?? 0,
+      filingDate: r.receipt_date ?? "",
+      documentUrl: r.document_url ?? r.pdf_url ?? ""
+    };
+  }
+};
+
+// src/integrations/public-records/propublica990-client.ts
+var ProPublica990ClientError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ProPublica990ClientError";
+  }
+};
+var LOG_PREFIX2 = "[OSINT:IRS990]";
+var ProPublica990Client = class {
+  baseUrl = "https://projects.propublica.org/nonprofits/api/v2";
+  timeout;
+  maxPages;
+  rateLimiter;
+  constructor(config = {}) {
+    this.timeout = config.timeout ?? 15e3;
+    this.maxPages = config.maxPages ?? 10;
+    this.rateLimiter = createRateLimiter("ProPublica990", 5, 1e3);
+  }
+  // -----------------------------------------------------------------------
+  // Internal helpers
+  // -----------------------------------------------------------------------
+  async request(endpoint, params = {}) {
+    await this.rateLimiter.acquire();
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== "") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      console.log(`${LOG_PREFIX2} GET ${endpoint}`);
+      const response = await fetch(url.toString(), {
+        headers: { Accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new ProPublica990ClientError(
+          `ProPublica API error ${response.status}: ${response.statusText} \u2014 ${body}`,
+          response.status
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ProPublica990ClientError) throw error;
+      if (error.name === "AbortError") {
+        throw new ProPublica990ClientError("ProPublica request timed out");
+      }
+      throw new ProPublica990ClientError(
+        `ProPublica network error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Search organizations
+  // -----------------------------------------------------------------------
+  async searchOrganizations(query, state) {
+    const allOrgs = [];
+    let page = 0;
+    while (page < this.maxPages) {
+      const body = await this.request(
+        `/search.json`,
+        {
+          q: query,
+          state,
+          page
+        }
+      );
+      const orgs = body.organizations ?? [];
+      if (orgs.length === 0) break;
+      for (const r of orgs) {
+        allOrgs.push(this.mapOrg(r));
+      }
+      if (orgs.length < 25) break;
+      page++;
+    }
+    return allOrgs;
+  }
+  // -----------------------------------------------------------------------
+  // Get single organization
+  // -----------------------------------------------------------------------
+  async getOrganization(ein) {
+    const normalizedEin = ein.replace(/-/g, "");
+    const body = await this.request(
+      `/organizations/${normalizedEin}.json`
+    );
+    const org = body.organization ?? {};
+    const filings = (body.filings_with_data ?? []).map(
+      (f) => this.mapFiling(f)
+    );
+    return {
+      ein: org.ein ? String(org.ein) : normalizedEin,
+      name: org.name ?? "",
+      city: org.city ?? "",
+      state: org.state ?? "",
+      nteeCode: org.ntee_code ?? "",
+      subsectionCode: org.subsection_code ?? null,
+      classificationCodes: org.classification_codes ?? "",
+      rulingDate: org.ruling_date ?? "",
+      filings
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Get filings for an EIN
+  // -----------------------------------------------------------------------
+  async getFilings(ein) {
+    const detail = await this.getOrganization(ein);
+    return detail.filings;
+  }
+  // -----------------------------------------------------------------------
+  // Mappers
+  // -----------------------------------------------------------------------
+  mapOrg(r) {
+    return {
+      ein: r.ein ? String(r.ein) : "",
+      name: r.name ?? "",
+      city: r.city ?? "",
+      state: r.state ?? "",
+      nteeCode: r.ntee_code ?? "",
+      subsectionCode: r.subsection_code ?? null,
+      classificationCodes: r.classification_codes ?? "",
+      rulingDate: r.ruling_date ?? "",
+      score: r.score ?? 0
+    };
+  }
+  mapFiling(f) {
+    return {
+      taxPeriod: f.tax_prd ? String(f.tax_prd) : "",
+      taxPeriodBegin: f.tax_prd_yr ? `${f.tax_prd_yr}-01-01` : "",
+      taxPeriodEnd: f.tax_prd ? String(f.tax_prd) : "",
+      formType: f.formtype ?? f.form_type ?? "",
+      pdfUrl: f.pdf_url ?? "",
+      updatedAt: f.updated ?? "",
+      totalRevenue: f.totrevenue ?? 0,
+      totalExpenses: f.totfuncexpns ?? 0,
+      totalAssets: f.totassetsend ?? 0,
+      totalLiabilities: f.totliabend ?? 0
+    };
+  }
+};
+
+// src/integrations/public-records/usaspending-client.ts
+var USASpendingClientError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "USASpendingClientError";
+  }
+};
+var LOG_PREFIX3 = "[OSINT:USASpending]";
+var USASpendingClient = class {
+  baseUrl = "https://api.usaspending.gov/api/v2";
+  timeout;
+  maxPages;
+  rateLimiter;
+  constructor(config = {}) {
+    this.timeout = config.timeout ?? 2e4;
+    this.maxPages = config.maxPages ?? 10;
+    this.rateLimiter = createRateLimiter("USASpending", 10, 1e3);
+  }
+  // -----------------------------------------------------------------------
+  // Internal helpers
+  // -----------------------------------------------------------------------
+  async post(endpoint, body) {
+    await this.rateLimiter.acquire();
+    const url = `${this.baseUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      console.log(`${LOG_PREFIX3} POST ${endpoint}`);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new USASpendingClientError(
+          `USAspending API error ${response.status}: ${response.statusText} \u2014 ${text}`,
+          response.status
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof USASpendingClientError) throw error;
+      if (error.name === "AbortError") {
+        throw new USASpendingClientError("USAspending request timed out");
+      }
+      throw new USASpendingClientError(
+        `USAspending network error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async get(endpoint, params = {}) {
+    await this.rateLimiter.acquire();
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== "") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      console.log(`${LOG_PREFIX3} GET ${endpoint}`);
+      const response = await fetch(url.toString(), {
+        headers: { Accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new USASpendingClientError(
+          `USAspending API error ${response.status}: ${response.statusText} \u2014 ${text}`,
+          response.status
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof USASpendingClientError) throw error;
+      if (error.name === "AbortError") {
+        throw new USASpendingClientError("USAspending request timed out");
+      }
+      throw new USASpendingClientError(
+        `USAspending network error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Awards search
+  // -----------------------------------------------------------------------
+  async searchAwards(filters = {}) {
+    const allAwards = [];
+    let page = 1;
+    while (page <= this.maxPages) {
+      const apiFilters = {};
+      if (filters.keyword) {
+        apiFilters.keywords = [filters.keyword];
+      }
+      if (filters.recipient) {
+        apiFilters.recipient_search_text = [filters.recipient];
+      }
+      if (filters.agency) {
+        apiFilters.agencies = [
+          {
+            type: "awarding",
+            tier: "toptier",
+            name: filters.agency
+          }
+        ];
+      }
+      if (filters.dateRange) {
+        apiFilters.time_period = [
+          {
+            start_date: filters.dateRange.start,
+            end_date: filters.dateRange.end
+          }
+        ];
+      }
+      if (filters.awardType && filters.awardType.length > 0) {
+        apiFilters.award_type_codes = filters.awardType;
+      }
+      const body = await this.post("/search/spending_by_award/", {
+        filters: apiFilters,
+        fields: [
+          "Award ID",
+          "Description",
+          "Award Amount",
+          "Total Outlays",
+          "Start Date",
+          "End Date",
+          "Recipient Name",
+          "Awarding Agency",
+          "Awarding Sub Agency",
+          "Funding Agency",
+          "Place of Performance City Code",
+          "Place of Performance State Code",
+          "generated_unique_award_id",
+          "recipient_id",
+          "Award Type"
+        ],
+        page,
+        limit: 100,
+        sort: "Award Amount",
+        order: "desc"
+      });
+      const results = body.results ?? [];
+      if (results.length === 0) break;
+      for (const r of results) {
+        allAwards.push({
+          awardId: r["Award ID"] ?? "",
+          generatedUniqueAwardId: r.generated_unique_award_id ?? "",
+          type: r["Award Type"] ?? "",
+          typeDescription: r["Award Type"] ?? "",
+          description: r["Description"] ?? "",
+          totalObligationAmount: r["Award Amount"] ?? 0,
+          totalOutlayAmount: r["Total Outlays"] ?? 0,
+          dateOfAward: r["Start Date"] ?? "",
+          startDate: r["Start Date"] ?? "",
+          endDate: r["End Date"] ?? "",
+          recipientName: r["Recipient Name"] ?? "",
+          recipientUei: r.recipient_id ?? "",
+          awardingAgencyName: r["Awarding Agency"] ?? "",
+          awardingSubAgencyName: r["Awarding Sub Agency"] ?? "",
+          fundingAgencyName: r["Funding Agency"] ?? "",
+          placeOfPerformanceCity: r["Place of Performance City Code"] ?? "",
+          placeOfPerformanceState: r["Place of Performance State Code"] ?? ""
+        });
+      }
+      if (!body.page_metadata || page >= (body.page_metadata.num_pages ?? 1)) {
+        break;
+      }
+      page++;
+    }
+    return allAwards;
+  }
+  // -----------------------------------------------------------------------
+  // Recipients
+  // -----------------------------------------------------------------------
+  async searchRecipients(query) {
+    const allRecipients = [];
+    let page = 1;
+    while (page <= this.maxPages) {
+      const body = await this.post("/recipient/duns/", {
+        keyword: query,
+        page,
+        limit: 100
+      });
+      const results = body.results ?? [];
+      if (results.length === 0) break;
+      for (const r of results) {
+        allRecipients.push(this.mapRecipient(r));
+      }
+      if (results.length < 100) break;
+      page++;
+    }
+    return allRecipients;
+  }
+  async getRecipient(recipientId) {
+    const body = await this.get(
+      `/recipient/${encodeURIComponent(recipientId)}/`
+    );
+    return this.mapRecipient(body);
+  }
+  mapRecipient(r) {
+    return {
+      recipientId: r.recipient_id ?? r.id ?? "",
+      name: r.name ?? r.recipient_name ?? "",
+      uei: r.uei ?? "",
+      duns: r.duns ?? "",
+      recipientLevel: r.recipient_level ?? "",
+      totalTransactionAmount: r.total_transaction_amount ?? 0,
+      totalFaceValueOfLoans: r.total_face_value_of_loans ?? 0,
+      totalContractAmount: r.total_contract_amount ?? 0,
+      totalGrantAmount: r.total_grant_amount ?? 0,
+      city: r.location?.city_name ?? r.city ?? "",
+      state: r.location?.state_code ?? r.state ?? "",
+      congressionalDistrict: r.location?.congressional_code ?? "",
+      businessTypes: r.business_types ?? []
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Agency spending
+  // -----------------------------------------------------------------------
+  async getAgencySpending(agencyCode, fiscalYear) {
+    const fy = fiscalYear ?? (/* @__PURE__ */ new Date()).getFullYear();
+    const body = await this.get(
+      `/agency/${agencyCode}/`,
+      { fiscal_year: fy }
+    );
+    return {
+      agencyCode: body.toptier_code ?? agencyCode,
+      agencyName: body.name ?? "",
+      fiscalYear: fy,
+      totalBudgetaryResources: body.budget_authority_amount ?? 0,
+      totalObligations: body.obligated_amount ?? 0,
+      totalOutlays: body.outlay_amount ?? 0,
+      congressionalJustificationUrl: body.congressional_justification_url ?? ""
+    };
+  }
+};
+
+// src/integrations/public-records/sec-edgar-client.ts
+var SECEdgarClientError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "SECEdgarClientError";
+  }
+};
+var LOG_PREFIX4 = "[OSINT:SEC]";
+var SECEdgarClient = class {
+  dataBaseUrl = "https://data.sec.gov";
+  searchBaseUrl = "https://efts.sec.gov/LATEST";
+  userAgent;
+  timeout;
+  maxPages;
+  rateLimiter;
+  /** Cache ticker -> CIK lookups so we don't repeat the same search */
+  tickerCikCache = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.userAgent = config.userAgent ?? env.SEC_EDGAR_USER_AGENT ?? "OpenSentinel/2.1 (contact@opensentinel.ai)";
+    this.timeout = config.timeout ?? 15e3;
+    this.maxPages = config.maxPages ?? 10;
+    this.rateLimiter = createRateLimiter("SEC", 10, 1e3);
+  }
+  // -----------------------------------------------------------------------
+  // Internal helpers
+  // -----------------------------------------------------------------------
+  /**
+   * Pad a CIK number to 10 digits with leading zeros.
+   */
+  padCik(cik) {
+    return String(cik).replace(/\D/g, "").padStart(10, "0");
+  }
+  async fetchJson(url) {
+    await this.rateLimiter.acquire();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      console.log(`${LOG_PREFIX4} GET ${url}`);
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": this.userAgent,
+          Accept: "application/json"
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new SECEdgarClientError(
+          `SEC EDGAR error ${response.status}: ${response.statusText} \u2014 ${body}`,
+          response.status
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SECEdgarClientError) throw error;
+      if (error.name === "AbortError") {
+        throw new SECEdgarClientError("SEC EDGAR request timed out");
+      }
+      throw new SECEdgarClientError(
+        `SEC EDGAR network error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Search companies (full-text search endpoint)
+  // -----------------------------------------------------------------------
+  async searchCompanies(query) {
+    const url = new URL(`${this.searchBaseUrl}/search-index`);
+    url.searchParams.set("q", query);
+    url.searchParams.set("dateRange", "custom");
+    url.searchParams.set("forms", "10-K");
+    const searchUrl = new URL(`${this.searchBaseUrl}/search-index`);
+    searchUrl.searchParams.set("q", `"${query}"`);
+    searchUrl.searchParams.set("forms", "10-K");
+    try {
+      const tickers = await this.fetchJson(`${this.dataBaseUrl}/files/company_tickers.json`);
+      const lowerQuery = query.toLowerCase();
+      const matches = [];
+      for (const entry of Object.values(tickers)) {
+        if (entry.title.toLowerCase().includes(lowerQuery) || entry.ticker.toLowerCase().includes(lowerQuery)) {
+          matches.push({
+            cik: this.padCik(entry.cik_str),
+            name: entry.title,
+            ticker: entry.ticker,
+            exchange: "",
+            sic: "",
+            sicDescription: "",
+            stateOfIncorporation: "",
+            fiscalYearEnd: ""
+          });
+        }
+        if (matches.length >= 25) break;
+      }
+      return matches;
+    } catch (error) {
+      console.log(`${LOG_PREFIX4} Ticker file search failed, falling back to EFTS`);
+      const eftsBody = await this.fetchJson(
+        `${this.searchBaseUrl}/search-index?q=${encodeURIComponent(query)}&forms=10-K`
+      );
+      const hits = eftsBody.hits?.hits ?? [];
+      return hits.slice(0, 25).map((h) => ({
+        cik: this.padCik(h._source?.entity_id ?? ""),
+        name: h._source?.entity_name ?? "",
+        ticker: "",
+        exchange: "",
+        sic: "",
+        sicDescription: "",
+        stateOfIncorporation: "",
+        fiscalYearEnd: ""
+      }));
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Company filings
+  // -----------------------------------------------------------------------
+  async getCompanyFilings(cik, formType) {
+    const paddedCik = this.padCik(cik);
+    const body = await this.fetchJson(
+      `${this.dataBaseUrl}/submissions/CIK${paddedCik}.json`
+    );
+    const recent = body.filings?.recent ?? {};
+    const accessionNumbers = recent.accessionNumber ?? [];
+    const forms = recent.form ?? [];
+    const filingDates = recent.filingDate ?? [];
+    const reportDates = recent.reportDate ?? [];
+    const acceptanceDateTimes = recent.acceptanceDateTime ?? [];
+    const primaryDocuments = recent.primaryDocument ?? [];
+    const primaryDocDescriptions = recent.primaryDocDescription ?? [];
+    const sizes = recent.size ?? [];
+    const allFilings = [];
+    for (let i = 0; i < accessionNumbers.length; i++) {
+      const form = forms[i] ?? "";
+      if (formType && form !== formType) continue;
+      const accession = accessionNumbers[i] ?? "";
+      const accessionClean = accession.replace(/-/g, "");
+      allFilings.push({
+        accessionNumber: accession,
+        formType: form,
+        filingDate: filingDates[i] ?? "",
+        reportDate: reportDates[i] ?? "",
+        acceptanceDateTime: acceptanceDateTimes[i] ?? "",
+        primaryDocument: primaryDocuments[i] ?? "",
+        primaryDocDescription: primaryDocDescriptions[i] ?? "",
+        filingUrl: `https://www.sec.gov/Archives/edgar/data/${parseInt(cik, 10)}/${accessionClean}/${primaryDocuments[i] ?? ""}`,
+        size: sizes[i] ?? 0
+      });
+    }
+    const additionalFiles = body.filings?.files ?? [];
+    let pagesLoaded = 1;
+    for (const file of additionalFiles) {
+      if (pagesLoaded >= this.maxPages) break;
+      try {
+        const additionalBody = await this.fetchJson(
+          `${this.dataBaseUrl}/submissions/${file}`
+        );
+        const addAccessions = additionalBody.accessionNumber ?? [];
+        const addForms = additionalBody.form ?? [];
+        const addFilingDates = additionalBody.filingDate ?? [];
+        const addReportDates = additionalBody.reportDate ?? [];
+        const addAcceptanceDates = additionalBody.acceptanceDateTime ?? [];
+        const addPrimaryDocs = additionalBody.primaryDocument ?? [];
+        const addPrimaryDescriptions = additionalBody.primaryDocDescription ?? [];
+        const addSizes = additionalBody.size ?? [];
+        for (let i = 0; i < addAccessions.length; i++) {
+          const form = addForms[i] ?? "";
+          if (formType && form !== formType) continue;
+          const accession = addAccessions[i] ?? "";
+          const accessionClean = accession.replace(/-/g, "");
+          allFilings.push({
+            accessionNumber: accession,
+            formType: form,
+            filingDate: addFilingDates[i] ?? "",
+            reportDate: addReportDates[i] ?? "",
+            acceptanceDateTime: addAcceptanceDates[i] ?? "",
+            primaryDocument: addPrimaryDocs[i] ?? "",
+            primaryDocDescription: addPrimaryDescriptions[i] ?? "",
+            filingUrl: `https://www.sec.gov/Archives/edgar/data/${parseInt(cik, 10)}/${accessionClean}/${addPrimaryDocs[i] ?? ""}`,
+            size: addSizes[i] ?? 0
+          });
+        }
+        pagesLoaded++;
+      } catch (error) {
+        console.log(
+          `${LOG_PREFIX4} Failed to fetch additional filings page ${file}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        break;
+      }
+    }
+    return allFilings;
+  }
+  // -----------------------------------------------------------------------
+  // Insider transactions (Forms 3, 4, 5)
+  // -----------------------------------------------------------------------
+  async getInsiderTransactions(cik) {
+    const filings = await this.getCompanyFilings(cik, "4");
+    const transactions = [];
+    const paddedCik = this.padCik(cik);
+    try {
+      const body = await this.fetchJson(
+        `${this.dataBaseUrl}/api/xbrl/companyfacts/CIK${paddedCik}.json`
+      );
+      for (const filing of filings.slice(0, 100)) {
+        transactions.push({
+          accessionNumber: filing.accessionNumber,
+          filingDate: filing.filingDate,
+          reportingOwnerCik: "",
+          reportingOwnerName: filing.primaryDocDescription || "See filing",
+          isDirector: false,
+          isOfficer: false,
+          officerTitle: "",
+          transactionDate: filing.reportDate || filing.filingDate,
+          transactionCode: "",
+          transactionShares: 0,
+          transactionPricePerShare: 0,
+          sharesOwnedFollowing: 0,
+          directOrIndirect: "D"
+        });
+      }
+    } catch {
+      for (const filing of filings.slice(0, 100)) {
+        transactions.push({
+          accessionNumber: filing.accessionNumber,
+          filingDate: filing.filingDate,
+          reportingOwnerCik: "",
+          reportingOwnerName: filing.primaryDocDescription || "See filing",
+          isDirector: false,
+          isOfficer: false,
+          officerTitle: "",
+          transactionDate: filing.reportDate || filing.filingDate,
+          transactionCode: "",
+          transactionShares: 0,
+          transactionPricePerShare: 0,
+          sharesOwnedFollowing: 0,
+          directOrIndirect: "D"
+        });
+      }
+    }
+    return transactions;
+  }
+  // -----------------------------------------------------------------------
+  // Company facts (structured XBRL data)
+  // -----------------------------------------------------------------------
+  async getCompanyFacts(cik) {
+    const paddedCik = this.padCik(cik);
+    const body = await this.fetchJson(
+      `${this.dataBaseUrl}/api/xbrl/companyfacts/CIK${paddedCik}.json`
+    );
+    return {
+      cik: paddedCik,
+      entityName: body.entityName ?? "",
+      facts: body.facts ?? {}
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Ticker -> CIK lookup
+  // -----------------------------------------------------------------------
+  async lookupCikByTicker(ticker) {
+    const upperTicker = ticker.toUpperCase();
+    if (this.tickerCikCache.has(upperTicker)) {
+      return this.tickerCikCache.get(upperTicker);
+    }
+    try {
+      const tickers = await this.fetchJson(`${this.dataBaseUrl}/files/company_tickers.json`);
+      for (const entry of Object.values(tickers)) {
+        if (entry.ticker.toUpperCase() === upperTicker) {
+          const paddedCik = this.padCik(entry.cik_str);
+          this.tickerCikCache.set(upperTicker, paddedCik);
+          return paddedCik;
+        }
+      }
+      return null;
+    } catch (error) {
+      console.log(
+        `${LOG_PREFIX4} Ticker lookup failed for ${ticker}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+};
+
+// src/integrations/public-records/opencorporates-client.ts
+var OpenCorporatesClientError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "OpenCorporatesClientError";
+  }
+};
+var LOG_PREFIX5 = "[OSINT:OpenCorporates]";
+var OpenCorporatesClient = class {
+  baseUrl = "https://api.opencorporates.com/v0.4";
+  apiToken;
+  timeout;
+  maxPages;
+  rateLimiter;
+  constructor(config = {}) {
+    this.apiToken = config.apiToken ?? env.OPENCORPORATES_API_TOKEN ?? "";
+    this.timeout = config.timeout ?? 15e3;
+    this.maxPages = config.maxPages ?? 10;
+    this.rateLimiter = createRateLimiter("OpenCorporates", 1, 1e3);
+  }
+  // -----------------------------------------------------------------------
+  // Internal helpers
+  // -----------------------------------------------------------------------
+  async request(endpoint, params = {}) {
+    await this.rateLimiter.acquire();
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    if (this.apiToken) {
+      url.searchParams.set("api_token", this.apiToken);
+    }
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== "") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      console.log(`${LOG_PREFIX5} GET ${endpoint}`);
+      const response = await fetch(url.toString(), {
+        headers: { Accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new OpenCorporatesClientError(
+          `OpenCorporates API error ${response.status}: ${response.statusText} \u2014 ${body}`,
+          response.status
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof OpenCorporatesClientError) throw error;
+      if (error.name === "AbortError") {
+        throw new OpenCorporatesClientError(
+          "OpenCorporates request timed out"
+        );
+      }
+      throw new OpenCorporatesClientError(
+        `OpenCorporates network error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Search companies
+  // -----------------------------------------------------------------------
+  async searchCompanies(query, jurisdiction) {
+    const allCompanies = [];
+    let page = 1;
+    while (page <= this.maxPages) {
+      const params = {
+        q: query,
+        page,
+        per_page: 30
+      };
+      if (jurisdiction) {
+        params.jurisdiction_code = jurisdiction;
+      }
+      const body = await this.request("/companies/search", params);
+      const companies = body.results?.companies ?? [];
+      if (companies.length === 0) break;
+      for (const wrapper of companies) {
+        const c = wrapper.company ?? wrapper;
+        allCompanies.push(this.mapCompany(c));
+      }
+      const totalPages = body.results?.total_pages ?? 1;
+      if (page >= totalPages || companies.length < 30) break;
+      page++;
+    }
+    return allCompanies;
+  }
+  // -----------------------------------------------------------------------
+  // Get single company
+  // -----------------------------------------------------------------------
+  async getCompany(jurisdictionCode, companyNumber) {
+    const body = await this.request(
+      `/companies/${encodeURIComponent(jurisdictionCode)}/${encodeURIComponent(companyNumber)}`
+    );
+    const c = body.results?.company ?? body.company ?? {};
+    return this.mapCompany(c);
+  }
+  // -----------------------------------------------------------------------
+  // Search officers
+  // -----------------------------------------------------------------------
+  async searchOfficers(query, jurisdiction) {
+    const allOfficers = [];
+    let page = 1;
+    while (page <= this.maxPages) {
+      const params = {
+        q: query,
+        page,
+        per_page: 30
+      };
+      if (jurisdiction) {
+        params.jurisdiction_code = jurisdiction;
+      }
+      const body = await this.request("/officers/search", params);
+      const officers = body.results?.officers ?? [];
+      if (officers.length === 0) break;
+      for (const wrapper of officers) {
+        const o = wrapper.officer ?? wrapper;
+        allOfficers.push(this.mapOfficer(o));
+      }
+      const totalPages = body.results?.total_pages ?? 1;
+      if (page >= totalPages || officers.length < 30) break;
+      page++;
+    }
+    return allOfficers;
+  }
+  // -----------------------------------------------------------------------
+  // Get filings for a company
+  // -----------------------------------------------------------------------
+  async getFilings(jurisdictionCode, companyNumber) {
+    const allFilings = [];
+    let page = 1;
+    while (page <= this.maxPages) {
+      const body = await this.request(
+        `/companies/${encodeURIComponent(jurisdictionCode)}/${encodeURIComponent(companyNumber)}/filings`,
+        { page, per_page: 30 }
+      );
+      const filings = body.results?.filings ?? [];
+      if (filings.length === 0) break;
+      for (const wrapper of filings) {
+        const f = wrapper.filing ?? wrapper;
+        allFilings.push(this.mapFiling(f));
+      }
+      const totalPages = body.results?.total_pages ?? 1;
+      if (page >= totalPages || filings.length < 30) break;
+      page++;
+    }
+    return allFilings;
+  }
+  // -----------------------------------------------------------------------
+  // Mappers
+  // -----------------------------------------------------------------------
+  mapCompany(c) {
+    const officers = (c.officers ?? []).map(
+      (wrapper) => {
+        const o = wrapper.officer ?? wrapper;
+        return this.mapOfficer(o);
+      }
+    );
+    return {
+      companyNumber: c.company_number ?? "",
+      name: c.name ?? "",
+      jurisdictionCode: c.jurisdiction_code ?? "",
+      incorporationDate: c.incorporation_date ?? "",
+      dissolutionDate: c.dissolution_date ?? "",
+      companyType: c.company_type ?? "",
+      registryUrl: c.registry_url ?? "",
+      status: c.current_status ?? c.status ?? "",
+      registeredAddress: c.registered_address_in_full ?? c.registered_address ?? "",
+      agentName: c.agent_name ?? "",
+      agentAddress: c.agent_address ?? "",
+      officers,
+      openCorporatesUrl: c.opencorporates_url ?? "",
+      source: c.source?.publisher ?? "",
+      updatedAt: c.updated_at ?? ""
+    };
+  }
+  mapOfficer(o) {
+    const company = o.company ?? {};
+    return {
+      id: o.id ?? 0,
+      name: o.name ?? "",
+      position: o.position ?? "",
+      startDate: o.start_date ?? "",
+      endDate: o.end_date ?? "",
+      nationality: o.nationality ?? "",
+      occupation: o.occupation ?? "",
+      companyNumber: company.company_number ?? "",
+      companyName: company.name ?? "",
+      jurisdictionCode: company.jurisdiction_code ?? ""
+    };
+  }
+  mapFiling(f) {
+    return {
+      id: f.id ?? 0,
+      title: f.title ?? "",
+      date: f.date ?? "",
+      description: f.description ?? "",
+      filingType: f.filing_type ?? "",
+      url: f.url ?? "",
+      openCorporatesUrl: f.opencorporates_url ?? ""
+    };
+  }
+};
+
+// src/integrations/public-records/index.ts
+var PublicRecords = class {
+  fec;
+  irs990;
+  usaspending;
+  sec;
+  opencorporates;
+  constructor(config = {}) {
+    this.fec = new FECClient(config.fec);
+    this.irs990 = new ProPublica990Client(config.irs990);
+    this.usaspending = new USASpendingClient(config.usaspending);
+    this.sec = new SECEdgarClient(config.sec);
+    this.opencorporates = new OpenCorporatesClient(config.opencorporates);
+  }
+};
+function createPublicRecords(config = {}) {
+  return new PublicRecords(config);
+}
+
+// src/integrations/neo4j/client.ts
+import neo4j from "neo4j-driver";
+var Neo4jClient = class {
+  driver;
+  database;
+  constructor(config) {
+    const uri = config?.uri ?? env.NEO4J_URI;
+    const user = config?.user ?? env.NEO4J_USER;
+    const password = config?.password ?? env.NEO4J_PASSWORD;
+    this.database = config?.database ?? env.NEO4J_DATABASE;
+    try {
+      this.driver = neo4j.driver(uri, neo4j.auth.basic(user, password));
+      console.log("[Neo4j] Driver created for", uri);
+    } catch (err) {
+      console.log("[Neo4j] Failed to create driver:", err);
+      throw err;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Public helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Execute a read-only Cypher query and return the result records.
+   */
+  async runQuery(cypher, params) {
+    const session = this.getSession("READ");
+    try {
+      const result = await session.run(cypher, params ?? {});
+      return result;
+    } catch (err) {
+      console.log("[Neo4j] Read query failed:", err);
+      throw err;
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Execute a write Cypher query and return the result records.
+   */
+  async runWrite(cypher, params) {
+    const session = this.getSession("WRITE");
+    try {
+      const result = await session.run(cypher, params ?? {});
+      return result;
+    } catch (err) {
+      console.log("[Neo4j] Write query failed:", err);
+      throw err;
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Verify that the driver can reach the Neo4j server.
+   */
+  async verifyConnectivity() {
+    try {
+      await this.driver.verifyConnectivity();
+      console.log("[Neo4j] Connectivity verified");
+      return true;
+    } catch (err) {
+      console.log("[Neo4j] Connectivity check failed:", err);
+      return false;
+    }
+  }
+  /**
+   * Get a raw session for advanced use-cases (caller is responsible for closing).
+   */
+  getSession(defaultAccessMode = "READ") {
+    return this.driver.session({
+      database: this.database,
+      defaultAccessMode: defaultAccessMode === "READ" ? neo4j.session.READ : neo4j.session.WRITE
+    });
+  }
+  /**
+   * Gracefully close the underlying driver.
+   */
+  async close() {
+    try {
+      await this.driver.close();
+      console.log("[Neo4j] Driver closed");
+    } catch (err) {
+      console.log("[Neo4j] Error closing driver:", err);
+    }
+  }
+};
+var _instance = null;
+function getNeo4jClient(config) {
+  if (!_instance) {
+    _instance = new Neo4jClient(config);
+  }
+  return _instance;
+}
+
+// src/integrations/neo4j/graph-ops.ts
+import { eq, ilike } from "drizzle-orm";
+async function findEntitiesByName(name, fuzzy = false) {
+  if (fuzzy) {
+    try {
+      const client = getNeo4jClient();
+      const safeName = name.replace(/[+\-&|!(){}[\]^"~*?:\\/]/g, "\\$&");
+      const result = await client.runQuery(
+        `
+        CALL db.index.fulltext.queryNodes("entity_fulltext", $query)
+        YIELD node, score
+        RETURN node.pgId   AS pgId,
+               node.type   AS type,
+               node.name   AS name,
+               node.aliases      AS aliases,
+               node.description  AS description,
+               node.importance   AS importance,
+               node.source       AS source,
+               score
+        ORDER BY score DESC
+        LIMIT 25
+        `,
+        { query: `${safeName}~` }
+      );
+      return result.records.map((r) => ({
+        pgId: r.get("pgId"),
+        type: r.get("type"),
+        name: r.get("name"),
+        aliases: r.get("aliases"),
+        description: r.get("description"),
+        importance: typeof r.get("importance") === "number" ? r.get("importance") : void 0,
+        source: r.get("source")
+      }));
+    } catch (err) {
+      console.log("[Neo4j] Fulltext search failed, falling back to Postgres:", err);
+    }
+  }
+  const rows = await db.select().from(graphEntities).where(ilike(graphEntities.name, `%${name}%`)).limit(25);
+  return rows.map((r) => ({
+    pgId: r.id,
+    type: r.type,
+    name: r.name,
+    aliases: r.aliases ?? [],
+    description: r.description ?? void 0,
+    attributes: r.attributes ?? {},
+    importance: r.importance ?? 50
+  }));
+}
+async function createRelationship(sourceId, targetId, type, attrs) {
+  const [row] = await db.insert(graphRelationships).values({
+    sourceEntityId: sourceId,
+    targetEntityId: targetId,
+    type,
+    strength: attrs?.strength ?? 50,
+    bidirectional: attrs?.bidirectional ?? false,
+    context: attrs?.context ?? null,
+    attributes: attrs?.attributes ?? {}
+  }).returning({ id: graphRelationships.id });
+  const pgId = row.id;
+  try {
+    const client = getNeo4jClient();
+    await client.runWrite(
+      `
+      MATCH (a:Entity {pgId: $sourceId}), (b:Entity {pgId: $targetId})
+      CREATE (a)-[r:RELATES_TO {
+        pgId:     $pgId,
+        type:     $type,
+        strength: $strength,
+        context:  $context,
+        source:   $source
+      }]->(b)
+      `,
+      {
+        sourceId,
+        targetId,
+        pgId,
+        type,
+        strength: attrs?.strength ?? 50,
+        context: attrs?.context ?? "",
+        source: attrs?.source ?? ""
+      }
+    );
+  } catch (err) {
+    console.log("[Neo4j] Failed to create relationship in Neo4j:", err);
+  }
+  return pgId;
+}
+async function getNeighbors(entityPgId, depth = 2) {
+  const client = getNeo4jClient();
+  try {
+    const result = await client.runQuery(
+      `
+      MATCH path = (start:Entity {pgId: $pgId})-[*1..${Math.min(depth, 10)}]-(neighbor:Entity)
+      WITH DISTINCT neighbor, relationships(path) AS rels, nodes(path) AS ns
+      UNWIND rels AS rel
+      WITH COLLECT(DISTINCT {
+        pgId:       neighbor.pgId,
+        name:       neighbor.name,
+        type:       neighbor.type,
+        importance: neighbor.importance
+      }) AS nodeList,
+      COLLECT(DISTINCT {
+        sourcePgId: startNode(rel).pgId,
+        targetPgId: endNode(rel).pgId,
+        type:       rel.type,
+        strength:   rel.strength
+      }) AS edgeList
+      RETURN nodeList, edgeList
+      `,
+      { pgId: entityPgId }
+    );
+    if (result.records.length === 0) {
+      return { nodes: [], edges: [] };
+    }
+    const record = result.records[0];
+    const nodes = record.get("nodeList") ?? [];
+    const edges = record.get("edgeList") ?? [];
+    return { nodes, edges };
+  } catch (err) {
+    console.log("[Neo4j] getNeighbors failed:", err);
+    return { nodes: [], edges: [] };
+  }
+}
+async function findShortestPath(sourcePgId, targetPgId) {
+  const client = getNeo4jClient();
+  try {
+    const result = await client.runQuery(
+      `
+      MATCH (a:Entity {pgId: $sourcePgId}), (b:Entity {pgId: $targetPgId}),
+            path = shortestPath((a)-[*..15]-(b))
+      WITH nodes(path) AS ns, relationships(path) AS rels, length(path) AS pathLen
+      RETURN
+        [n IN ns | {pgId: n.pgId, name: n.name, type: n.type, importance: n.importance}] AS nodes,
+        [r IN rels | {sourcePgId: startNode(r).pgId, targetPgId: endNode(r).pgId, type: r.type, strength: r.strength}] AS edges,
+        pathLen
+      `,
+      { sourcePgId, targetPgId }
+    );
+    if (result.records.length === 0) {
+      return null;
+    }
+    const record = result.records[0];
+    return {
+      nodes: record.get("nodes"),
+      edges: record.get("edges"),
+      length: typeof record.get("pathLen") === "object" ? record.get("pathLen").toNumber() : record.get("pathLen")
+    };
+  } catch (err) {
+    console.log("[Neo4j] findShortestPath failed:", err);
+    return null;
+  }
+}
+async function getCommunities() {
+  const client = getNeo4jClient();
+  try {
+    const result = await client.runQuery(
+      `
+      MATCH (e:Entity)
+      WITH collect(e) AS allNodes
+      UNWIND allNodes AS node
+      MATCH path = (node)-[*0..]-(connected:Entity)
+      WITH node, collect(DISTINCT connected) AS component
+      WITH component, component[0].pgId AS componentId
+      ORDER BY size(component) DESC
+      WITH DISTINCT componentId,
+           [m IN component | {pgId: m.pgId, name: m.name, type: m.type, importance: m.importance}] AS members
+      RETURN componentId, members
+      LIMIT 100
+      `
+    );
+    return result.records.map((r, idx) => ({
+      id: idx,
+      members: r.get("members")
+    }));
+  } catch (err) {
+    console.log("[Neo4j] getCommunities failed:", err);
+    return [];
+  }
+}
+async function runCustomCypher(cypher, params) {
+  const client = getNeo4jClient();
+  try {
+    const result = await client.runQuery(cypher, params);
+    return result.records.map((r) => r.toObject());
+  } catch (err) {
+    console.log("[Neo4j] Custom Cypher failed:", err);
+    throw err;
+  }
+}
+
+// src/core/intelligence/enrichment-pipeline.ts
+var LOG_PREFIX6 = "[OSINT:Enrich]";
+var _publicRecords = null;
+function getPublicRecords() {
+  if (!_publicRecords) _publicRecords = new PublicRecords();
+  return _publicRecords;
+}
+var ALL_SOURCES = ["fec", "irs990", "usaspending", "sec", "opencorporates"];
+async function enrichEntity(entityId, sources, depth = 1) {
+  if (!env.OSINT_ENABLED) {
+    console.log(`${LOG_PREFIX6} OSINT is disabled \u2014 skipping enrichment`);
+    return {
+      entityId,
+      entityName: "",
+      sourcesQueried: [],
+      newEntitiesCreated: 0,
+      newRelationshipsCreated: 0,
+      errors: ["OSINT_ENABLED is false"]
+    };
+  }
+  const rows = await db.select({
+    id: graphEntities.id,
+    name: graphEntities.name,
+    type: graphEntities.type,
+    attributes: graphEntities.attributes
+  }).from(graphEntities).where(eq2(graphEntities.id, entityId)).limit(1);
+  if (rows.length === 0) {
+    console.log(`${LOG_PREFIX6} Entity not found: ${entityId}`);
+    return {
+      entityId,
+      entityName: "",
+      sourcesQueried: [],
+      newEntitiesCreated: 0,
+      newRelationshipsCreated: 0,
+      errors: [`Entity ${entityId} not found`]
+    };
+  }
+  const entity = rows[0];
+  const entityName = entity.name;
+  const entityType = entity.type;
+  const attrs = entity.attributes ?? {};
+  console.log(
+    `${LOG_PREFIX6} Enriching "${entityName}" (${entityType}) \u2014 depth=${depth}`
+  );
+  const activeSources = (sources ?? [...ALL_SOURCES]).filter(
+    (s) => ALL_SOURCES.includes(s)
+  );
+  const enrichedFrom = attrs.enrichedFrom ?? [];
+  const pendingSources = activeSources.filter(
+    (s) => !enrichedFrom.includes(s)
+  );
+  if (pendingSources.length === 0) {
+    console.log(`${LOG_PREFIX6} "${entityName}" already enriched from all requested sources`);
+    return {
+      entityId,
+      entityName,
+      sourcesQueried: [],
+      newEntitiesCreated: 0,
+      newRelationshipsCreated: 0,
+      errors: []
+    };
+  }
+  const enricherMap = {
+    fec: enrichFromFEC,
+    irs990: enrichFromIRS990,
+    usaspending: enrichFromUSASpending,
+    sec: enrichFromSEC,
+    opencorporates: enrichFromOpenCorporates
+  };
+  let totalEntities = 0;
+  let totalRelationships = 0;
+  const allErrors = [];
+  const queriedSources = [];
+  const enrichmentPromises = pendingSources.map(async (source) => {
+    try {
+      const result = await enricherMap[source](entityId, entityName, entityType, attrs);
+      queriedSources.push(source);
+      totalEntities += result.entities;
+      totalRelationships += result.relationships;
+      allErrors.push(...result.errors);
+    } catch (err) {
+      const msg = `${source}: ${err instanceof Error ? err.message : String(err)}`;
+      console.error(`${LOG_PREFIX6} Top-level enricher error \u2014 ${msg}`);
+      allErrors.push(msg);
+      queriedSources.push(source);
+    }
+  });
+  await Promise.all(enrichmentPromises);
+  try {
+    const updatedEnrichedFrom = [.../* @__PURE__ */ new Set([...enrichedFrom, ...queriedSources])];
+    await db.update(graphEntities).set({
+      attributes: {
+        ...attrs,
+        enrichedFrom: updatedEnrichedFrom,
+        lastEnrichedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }).where(eq2(graphEntities.id, entityId));
+  } catch (err) {
+    console.error(`${LOG_PREFIX6} Failed to update enrichment metadata for ${entityId}:`, err);
+  }
+  console.log(
+    `${LOG_PREFIX6} Enrichment complete for "${entityName}": ${totalEntities} entities, ${totalRelationships} relationships, ${allErrors.length} errors`
+  );
+  return {
+    entityId,
+    entityName,
+    sourcesQueried: queriedSources,
+    newEntitiesCreated: totalEntities,
+    newRelationshipsCreated: totalRelationships,
+    errors: allErrors
+  };
+}
+async function enrichFromFEC(entityId, entityName, entityType, attrs) {
+  const pr = getPublicRecords();
+  let entities = 0;
+  let relationships = 0;
+  const errors = [];
+  if (entityType === "person") {
+    try {
+      const contributions = await pr.fec.getDonorLookup(entityName);
+      console.log(
+        `${LOG_PREFIX6} FEC: found ${contributions.length} contributions for person "${entityName}"`
+      );
+      const committeeMap = /* @__PURE__ */ new Map();
+      for (const contrib of contributions) {
+        if (!contrib.committeeId) continue;
+        const existing = committeeMap.get(contrib.committeeId);
+        if (existing) {
+          existing.totalAmount += contrib.amount;
+          existing.count += 1;
+        } else {
+          committeeMap.set(contrib.committeeId, {
+            id: contrib.committeeId,
+            name: contrib.committeeName,
+            totalAmount: contrib.amount,
+            count: 1
+          });
+        }
+      }
+      for (const [fecCommitteeId, info] of committeeMap) {
+        try {
+          const resolved = await resolveEntity({
+            name: info.name,
+            type: "committee",
+            source: "fec",
+            identifiers: { fecId: fecCommitteeId },
+            attributes: {
+              fecCommitteeId
+            }
+          });
+          if (resolved.isNew) entities++;
+          await createRelationship(entityId, resolved.entityId, "donated_to", {
+            strength: Math.min(100, Math.round(info.totalAmount / 100)),
+            context: `${info.count} contribution(s) totaling $${info.totalAmount.toLocaleString()}`,
+            attributes: {
+              totalAmount: info.totalAmount,
+              contributionCount: info.count,
+              source: "fec"
+            },
+            source: "fec"
+          });
+          relationships++;
+        } catch (err) {
+          errors.push(`FEC committee resolution: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    } catch (err) {
+      errors.push(`FEC donor lookup: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+      const candidates = await pr.fec.searchCandidates(entityName);
+      for (const candidate of candidates.slice(0, 5)) {
+        try {
+          const resolved = await resolveEntity({
+            name: candidate.name,
+            type: "person",
+            source: "fec",
+            identifiers: { fecId: candidate.candidateId },
+            attributes: {
+              fecCandidateId: candidate.candidateId,
+              party: candidate.party,
+              office: candidate.office,
+              state: candidate.state,
+              district: candidate.district
+            }
+          });
+          if (resolved.entityId !== entityId) {
+            if (resolved.isNew) entities++;
+            await createRelationship(entityId, resolved.entityId, "related_to", {
+              context: `FEC candidate match: ${candidate.name} (${candidate.party})`,
+              attributes: { source: "fec", matchType: "candidate" },
+              source: "fec"
+            });
+            relationships++;
+          }
+        } catch (err) {
+          errors.push(`FEC candidate resolution: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    } catch (err) {
+      errors.push(`FEC candidate search: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  } else if (entityType === "organization" || entityType === "event") {
+    try {
+      const committees = await pr.fec.searchCommittees(entityName);
+      console.log(
+        `${LOG_PREFIX6} FEC: found ${committees.length} committees for org "${entityName}"`
+      );
+      for (const committee of committees.slice(0, 10)) {
+        try {
+          const resolved = await resolveEntity({
+            name: committee.name,
+            type: "committee",
+            source: "fec",
+            identifiers: { fecId: committee.committeeId },
+            attributes: {
+              fecCommitteeId: committee.committeeId,
+              designation: committee.designation,
+              committeeType: committee.type,
+              party: committee.party,
+              treasurerName: committee.treasurerName
+            }
+          });
+          if (resolved.isNew) entities++;
+          await createRelationship(entityId, resolved.entityId, "related_to", {
+            context: `FEC committee: ${committee.name} (${committee.designation})`,
+            attributes: { source: "fec", committeeType: committee.type },
+            source: "fec"
+          });
+          relationships++;
+          try {
+            const contributions = await pr.fec.getContributions({
+              committeeId: committee.committeeId
+            });
+            const donorMap = /* @__PURE__ */ new Map();
+            for (const c of contributions) {
+              if (!c.contributorName) continue;
+              const existing = donorMap.get(c.contributorName);
+              if (existing) {
+                existing.total += c.amount;
+                existing.count++;
+              } else {
+                donorMap.set(c.contributorName, {
+                  name: c.contributorName,
+                  total: c.amount,
+                  count: 1
+                });
+              }
+            }
+            const topDonors = [...donorMap.values()].sort((a, b) => b.total - a.total).slice(0, 10);
+            for (const donor of topDonors) {
+              try {
+                const donorResolved = await resolveEntity({
+                  name: donor.name,
+                  type: "person",
+                  source: "fec",
+                  attributes: {
+                    totalContributions: donor.total,
+                    contributionCount: donor.count
+                  }
+                });
+                if (donorResolved.isNew) entities++;
+                await createRelationship(
+                  donorResolved.entityId,
+                  resolved.entityId,
+                  "donated_to",
+                  {
+                    strength: Math.min(100, Math.round(donor.total / 100)),
+                    context: `${donor.count} contribution(s) totaling $${donor.total.toLocaleString()}`,
+                    attributes: {
+                      totalAmount: donor.total,
+                      contributionCount: donor.count,
+                      source: "fec"
+                    },
+                    source: "fec"
+                  }
+                );
+                relationships++;
+              } catch (err) {
+                errors.push(
+                  `FEC donor resolution (${donor.name}): ${err instanceof Error ? err.message : String(err)}`
+                );
+              }
+            }
+          } catch (err) {
+            errors.push(
+              `FEC contributions for ${committee.committeeId}: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        } catch (err) {
+          errors.push(
+            `FEC committee resolution (${committee.name}): ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    } catch (err) {
+      errors.push(`FEC committee search: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { entities, relationships, errors };
+}
+async function enrichFromIRS990(entityId, entityName, entityType, attrs) {
+  const pr = getPublicRecords();
+  let entities = 0;
+  let relationships = 0;
+  const errors = [];
+  if (entityType !== "organization" && entityType !== "event") {
+    return { entities, relationships, errors };
+  }
+  try {
+    const orgs = await pr.irs990.searchOrganizations(entityName);
+    console.log(
+      `${LOG_PREFIX6} IRS990: found ${orgs.length} nonprofits for "${entityName}"`
+    );
+    for (const org of orgs.slice(0, 5)) {
+      if (!org.ein) continue;
+      try {
+        const detail = await pr.irs990.getOrganization(org.ein);
+        const recentFilings = detail.filings.slice(0, 3);
+        const financialSummary = {};
+        if (recentFilings.length > 0) {
+          const latest = recentFilings[0];
+          financialSummary.latestRevenue = latest.totalRevenue;
+          financialSummary.latestExpenses = latest.totalExpenses;
+          financialSummary.latestAssets = latest.totalAssets;
+          financialSummary.latestLiabilities = latest.totalLiabilities;
+          financialSummary.latestTaxPeriod = latest.taxPeriod;
+          financialSummary.filingCount = detail.filings.length;
+        }
+        const resolved = await resolveEntity({
+          name: detail.name || org.name,
+          type: "organization",
+          source: "irs990",
+          identifiers: { ein: org.ein },
+          attributes: {
+            ein: org.ein,
+            city: detail.city || org.city,
+            state: detail.state || org.state,
+            nteeCode: detail.nteeCode || org.nteeCode,
+            rulingDate: detail.rulingDate || org.rulingDate,
+            ...financialSummary,
+            filings: recentFilings.map((f) => ({
+              taxPeriod: f.taxPeriod,
+              formType: f.formType,
+              totalRevenue: f.totalRevenue,
+              totalExpenses: f.totalExpenses,
+              totalAssets: f.totalAssets,
+              totalLiabilities: f.totalLiabilities
+            }))
+          }
+        });
+        if (resolved.isNew) entities++;
+        if (resolved.entityId !== entityId) {
+          await createRelationship(entityId, resolved.entityId, "related_to", {
+            context: `IRS 990 nonprofit: ${org.name} (EIN: ${org.ein})`,
+            attributes: {
+              source: "irs990",
+              ein: org.ein,
+              ...financialSummary
+            },
+            source: "irs990"
+          });
+          relationships++;
+        } else {
+          try {
+            await db.update(graphEntities).set({
+              attributes: {
+                ...attrs,
+                ein: org.ein,
+                nteeCode: detail.nteeCode,
+                ...financialSummary,
+                irs990Filings: recentFilings.map((f) => ({
+                  taxPeriod: f.taxPeriod,
+                  formType: f.formType,
+                  totalRevenue: f.totalRevenue,
+                  totalExpenses: f.totalExpenses,
+                  totalAssets: f.totalAssets,
+                  totalLiabilities: f.totalLiabilities
+                }))
+              }
+            }).where(eq2(graphEntities.id, entityId));
+          } catch (err) {
+            errors.push(
+              `IRS990 attribute update: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      } catch (err) {
+        errors.push(
+          `IRS990 org detail (${org.ein}): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  } catch (err) {
+    errors.push(`IRS990 search: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return { entities, relationships, errors };
+}
+async function enrichFromUSASpending(entityId, entityName, entityType, attrs) {
+  const pr = getPublicRecords();
+  let entities = 0;
+  let relationships = 0;
+  const errors = [];
+  try {
+    const awards = await pr.usaspending.searchAwards({
+      keyword: entityName
+    });
+    console.log(
+      `${LOG_PREFIX6} USASpending: found ${awards.length} awards for "${entityName}"`
+    );
+    for (const award of awards.slice(0, 15)) {
+      try {
+        const awardCandidate = {
+          name: award.description || `Award ${award.awardId}`,
+          type: "contract",
+          source: "usaspending",
+          identifiers: { uei: award.recipientUei || void 0 },
+          attributes: {
+            awardId: award.awardId,
+            awardType: award.type,
+            typeDescription: award.typeDescription,
+            totalObligationAmount: award.totalObligationAmount,
+            totalOutlayAmount: award.totalOutlayAmount,
+            startDate: award.startDate,
+            endDate: award.endDate,
+            placeOfPerformanceCity: award.placeOfPerformanceCity,
+            placeOfPerformanceState: award.placeOfPerformanceState
+          }
+        };
+        const awardResolved = await resolveEntity(awardCandidate);
+        if (awardResolved.isNew) entities++;
+        if (award.recipientName) {
+          try {
+            const recipientResolved = await resolveEntity({
+              name: award.recipientName,
+              type: "organization",
+              source: "usaspending",
+              identifiers: { uei: award.recipientUei || void 0 },
+              attributes: {
+                uei: award.recipientUei
+              }
+            });
+            if (recipientResolved.isNew) entities++;
+            await createRelationship(
+              recipientResolved.entityId,
+              awardResolved.entityId,
+              "awarded_contract",
+              {
+                strength: Math.min(
+                  100,
+                  Math.round(Math.abs(award.totalObligationAmount) / 1e4)
+                ),
+                context: `Award ${award.awardId}: $${award.totalObligationAmount.toLocaleString()}`,
+                attributes: {
+                  amount: award.totalObligationAmount,
+                  awardType: award.type,
+                  source: "usaspending"
+                },
+                source: "usaspending"
+              }
+            );
+            relationships++;
+            if (recipientResolved.entityId !== entityId) {
+              await createRelationship(entityId, recipientResolved.entityId, "related_to", {
+                context: `Linked via USAspending award ${award.awardId}`,
+                attributes: { source: "usaspending" },
+                source: "usaspending"
+              });
+              relationships++;
+            }
+          } catch (err) {
+            errors.push(
+              `USASpending recipient (${award.recipientName}): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        if (award.awardingAgencyName) {
+          try {
+            const agencyResolved = await resolveEntity({
+              name: award.awardingAgencyName,
+              type: "organization",
+              source: "usaspending",
+              attributes: {
+                agencyType: "federal",
+                subAgency: award.awardingSubAgencyName
+              }
+            });
+            if (agencyResolved.isNew) entities++;
+            await createRelationship(
+              agencyResolved.entityId,
+              awardResolved.entityId,
+              "funded_by",
+              {
+                context: `Funded by ${award.awardingAgencyName}`,
+                attributes: {
+                  amount: award.totalObligationAmount,
+                  source: "usaspending"
+                },
+                source: "usaspending"
+              }
+            );
+            relationships++;
+          } catch (err) {
+            errors.push(
+              `USASpending agency (${award.awardingAgencyName}): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        if (award.fundingAgencyName && award.fundingAgencyName !== award.awardingAgencyName) {
+          try {
+            const fundingResolved = await resolveEntity({
+              name: award.fundingAgencyName,
+              type: "organization",
+              source: "usaspending",
+              attributes: { agencyType: "federal" }
+            });
+            if (fundingResolved.isNew) entities++;
+            await createRelationship(
+              fundingResolved.entityId,
+              awardResolved.entityId,
+              "funded_by",
+              {
+                context: `Funding agency: ${award.fundingAgencyName}`,
+                attributes: { source: "usaspending" },
+                source: "usaspending"
+              }
+            );
+            relationships++;
+          } catch (err) {
+            errors.push(
+              `USASpending funding agency (${award.fundingAgencyName}): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      } catch (err) {
+        errors.push(
+          `USASpending award (${award.awardId}): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  } catch (err) {
+    errors.push(`USASpending search: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return { entities, relationships, errors };
+}
+async function enrichFromSEC(entityId, entityName, entityType, attrs) {
+  const pr = getPublicRecords();
+  let entities = 0;
+  let relationships = 0;
+  const errors = [];
+  if (entityType !== "organization" && entityType !== "person") {
+    return { entities, relationships, errors };
+  }
+  try {
+    const companies = await pr.sec.searchCompanies(entityName);
+    console.log(
+      `${LOG_PREFIX6} SEC: found ${companies.length} companies for "${entityName}"`
+    );
+    for (const company of companies.slice(0, 5)) {
+      if (!company.cik) continue;
+      try {
+        const companyResolved = await resolveEntity({
+          name: company.name,
+          type: "organization",
+          source: "sec",
+          identifiers: { cik: company.cik },
+          attributes: {
+            cik: company.cik,
+            ticker: company.ticker,
+            exchange: company.exchange,
+            sic: company.sic,
+            sicDescription: company.sicDescription,
+            stateOfIncorporation: company.stateOfIncorporation,
+            fiscalYearEnd: company.fiscalYearEnd
+          }
+        });
+        if (companyResolved.isNew) entities++;
+        if (companyResolved.entityId !== entityId) {
+          await createRelationship(entityId, companyResolved.entityId, "related_to", {
+            context: `SEC EDGAR company match: ${company.name} (CIK: ${company.cik})`,
+            attributes: { source: "sec", cik: company.cik, ticker: company.ticker },
+            source: "sec"
+          });
+          relationships++;
+        }
+        try {
+          const transactions = await pr.sec.getInsiderTransactions(company.cik);
+          console.log(
+            `${LOG_PREFIX6} SEC: found ${transactions.length} insider transactions for CIK ${company.cik}`
+          );
+          const ownerMap = /* @__PURE__ */ new Map();
+          for (const tx of transactions) {
+            if (!tx.reportingOwnerName || tx.reportingOwnerName === "See filing")
+              continue;
+            const key = tx.reportingOwnerCik || tx.reportingOwnerName;
+            const existing = ownerMap.get(key);
+            if (existing) {
+              existing.transactionCount++;
+              existing.totalShares += Math.abs(tx.transactionShares);
+              existing.isDirector = existing.isDirector || tx.isDirector;
+              existing.isOfficer = existing.isOfficer || tx.isOfficer;
+              if (tx.officerTitle && !existing.officerTitle) {
+                existing.officerTitle = tx.officerTitle;
+              }
+            } else {
+              ownerMap.set(key, {
+                name: tx.reportingOwnerName,
+                cik: tx.reportingOwnerCik,
+                isDirector: tx.isDirector,
+                isOfficer: tx.isOfficer,
+                officerTitle: tx.officerTitle,
+                transactionCount: 1,
+                totalShares: Math.abs(tx.transactionShares)
+              });
+            }
+          }
+          const topInsiders = [...ownerMap.values()].sort((a, b) => b.totalShares - a.totalShares).slice(0, 15);
+          for (const insider of topInsiders) {
+            try {
+              const insiderResolved = await resolveEntity({
+                name: insider.name,
+                type: "person",
+                source: "sec",
+                identifiers: insider.cik ? { cik: insider.cik } : void 0,
+                attributes: {
+                  isDirector: insider.isDirector,
+                  isOfficer: insider.isOfficer,
+                  officerTitle: insider.officerTitle
+                }
+              });
+              if (insiderResolved.isNew) entities++;
+              const relType = insider.isOfficer || insider.isDirector ? "officer_of" : "insider_transaction";
+              await createRelationship(
+                insiderResolved.entityId,
+                companyResolved.entityId,
+                relType,
+                {
+                  strength: Math.min(100, 40 + insider.transactionCount * 5),
+                  context: insider.officerTitle ? `${insider.officerTitle} \u2014 ${insider.transactionCount} transaction(s)` : `${insider.transactionCount} insider transaction(s)`,
+                  attributes: {
+                    isDirector: insider.isDirector,
+                    isOfficer: insider.isOfficer,
+                    officerTitle: insider.officerTitle,
+                    transactionCount: insider.transactionCount,
+                    totalShares: insider.totalShares,
+                    source: "sec"
+                  },
+                  source: "sec"
+                }
+              );
+              relationships++;
+            } catch (err) {
+              errors.push(
+                `SEC insider (${insider.name}): ${err instanceof Error ? err.message : String(err)}`
+              );
+            }
+          }
+        } catch (err) {
+          errors.push(
+            `SEC insider transactions (CIK ${company.cik}): ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      } catch (err) {
+        errors.push(
+          `SEC company (${company.name}): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  } catch (err) {
+    errors.push(`SEC search: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return { entities, relationships, errors };
+}
+async function enrichFromOpenCorporates(entityId, entityName, entityType, attrs) {
+  const pr = getPublicRecords();
+  let entities = 0;
+  let relationships = 0;
+  const errors = [];
+  if (entityType !== "organization") {
+    if (entityType === "person") {
+      try {
+        const officers = await pr.opencorporates.searchOfficers(entityName);
+        console.log(
+          `${LOG_PREFIX6} OpenCorporates: found ${officers.length} officer records for person "${entityName}"`
+        );
+        for (const officer of officers.slice(0, 10)) {
+          if (!officer.companyName) continue;
+          try {
+            const companyResolved = await resolveEntity({
+              name: officer.companyName,
+              type: "organization",
+              source: "opencorporates",
+              attributes: {
+                companyNumber: officer.companyNumber,
+                jurisdictionCode: officer.jurisdictionCode
+              }
+            });
+            if (companyResolved.isNew) entities++;
+            await createRelationship(entityId, companyResolved.entityId, "officer_of", {
+              strength: 60,
+              context: `${officer.position || "Officer"} at ${officer.companyName}`,
+              attributes: {
+                position: officer.position,
+                startDate: officer.startDate,
+                endDate: officer.endDate,
+                nationality: officer.nationality,
+                occupation: officer.occupation,
+                source: "opencorporates"
+              },
+              source: "opencorporates"
+            });
+            relationships++;
+          } catch (err) {
+            errors.push(
+              `OpenCorporates officer company (${officer.companyName}): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      } catch (err) {
+        errors.push(
+          `OpenCorporates officer search: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      return { entities, relationships, errors };
+    }
+    return { entities, relationships, errors };
+  }
+  try {
+    const companies = await pr.opencorporates.searchCompanies(entityName);
+    console.log(
+      `${LOG_PREFIX6} OpenCorporates: found ${companies.length} companies for "${entityName}"`
+    );
+    for (const company of companies.slice(0, 5)) {
+      try {
+        const companyResolved = await resolveEntity({
+          name: company.name,
+          type: "organization",
+          source: "opencorporates",
+          attributes: {
+            companyNumber: company.companyNumber,
+            jurisdictionCode: company.jurisdictionCode,
+            incorporationDate: company.incorporationDate,
+            dissolutionDate: company.dissolutionDate,
+            companyType: company.companyType,
+            status: company.status,
+            registeredAddress: company.registeredAddress,
+            registryUrl: company.registryUrl,
+            openCorporatesUrl: company.openCorporatesUrl
+          }
+        });
+        if (companyResolved.isNew) entities++;
+        if (companyResolved.entityId !== entityId) {
+          await createRelationship(entityId, companyResolved.entityId, "related_to", {
+            context: `OpenCorporates match: ${company.name} (${company.jurisdictionCode})`,
+            attributes: {
+              source: "opencorporates",
+              companyNumber: company.companyNumber,
+              jurisdictionCode: company.jurisdictionCode
+            },
+            source: "opencorporates"
+          });
+          relationships++;
+        }
+        const inlineOfficers = company.officers ?? [];
+        for (const officer of inlineOfficers.slice(0, 15)) {
+          if (!officer.name) continue;
+          try {
+            const officerResolved = await resolveEntity({
+              name: officer.name,
+              type: "person",
+              source: "opencorporates",
+              attributes: {
+                position: officer.position,
+                nationality: officer.nationality,
+                occupation: officer.occupation
+              }
+            });
+            if (officerResolved.isNew) entities++;
+            await createRelationship(
+              officerResolved.entityId,
+              companyResolved.entityId,
+              "officer_of",
+              {
+                strength: 60,
+                context: `${officer.position || "Officer"} at ${company.name}`,
+                attributes: {
+                  position: officer.position,
+                  startDate: officer.startDate,
+                  endDate: officer.endDate,
+                  nationality: officer.nationality,
+                  occupation: officer.occupation,
+                  source: "opencorporates"
+                },
+                source: "opencorporates"
+              }
+            );
+            relationships++;
+          } catch (err) {
+            errors.push(
+              `OpenCorporates officer (${officer.name}): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        if (inlineOfficers.length === 0 && company.jurisdictionCode && company.companyNumber) {
+          try {
+            const detailedCompany = await pr.opencorporates.getCompany(
+              company.jurisdictionCode,
+              company.companyNumber
+            );
+            for (const officer of (detailedCompany.officers ?? []).slice(0, 15)) {
+              if (!officer.name) continue;
+              try {
+                const officerResolved = await resolveEntity({
+                  name: officer.name,
+                  type: "person",
+                  source: "opencorporates",
+                  attributes: {
+                    position: officer.position,
+                    nationality: officer.nationality,
+                    occupation: officer.occupation
+                  }
+                });
+                if (officerResolved.isNew) entities++;
+                await createRelationship(
+                  officerResolved.entityId,
+                  companyResolved.entityId,
+                  "officer_of",
+                  {
+                    strength: 60,
+                    context: `${officer.position || "Officer"} at ${company.name}`,
+                    attributes: {
+                      position: officer.position,
+                      startDate: officer.startDate,
+                      endDate: officer.endDate,
+                      source: "opencorporates"
+                    },
+                    source: "opencorporates"
+                  }
+                );
+                relationships++;
+              } catch (err) {
+                errors.push(
+                  `OpenCorporates officer (${officer.name}): ${err instanceof Error ? err.message : String(err)}`
+                );
+              }
+            }
+          } catch (err) {
+            errors.push(
+              `OpenCorporates company detail (${company.companyNumber}): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      } catch (err) {
+        errors.push(
+          `OpenCorporates company (${company.name}): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  } catch (err) {
+    errors.push(`OpenCorporates search: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return { entities, relationships, errors };
+}
+async function batchEnrich(opts) {
+  if (!env.OSINT_ENABLED) {
+    console.log(`${LOG_PREFIX6} OSINT is disabled \u2014 skipping batch enrichment`);
+    return [];
+  }
+  const limit = opts?.limit ?? 50;
+  const sources = (opts?.sources ?? [...ALL_SOURCES]).filter(
+    (s) => ALL_SOURCES.includes(s)
+  );
+  console.log(
+    `${LOG_PREFIX6} Starting batch enrichment \u2014 limit=${limit}, sources=${sources.join(",")}`
+  );
+  const candidates = await db.select({
+    id: graphEntities.id,
+    name: graphEntities.name,
+    attributes: graphEntities.attributes
+  }).from(graphEntities).where(
+    sql`(
+        ${graphEntities.attributes}->>'enrichedFrom' IS NULL
+        OR NOT ${graphEntities.attributes}->'enrichedFrom' @> ${JSON.stringify(sources)}::jsonb
+      )`
+  ).limit(limit);
+  console.log(
+    `${LOG_PREFIX6} Found ${candidates.length} entities needing enrichment`
+  );
+  const results = [];
+  for (const candidate of candidates) {
+    const enrichedFrom = candidate.attributes?.enrichedFrom ?? [];
+    const missingSources = sources.filter((s) => !enrichedFrom.includes(s));
+    if (missingSources.length === 0) continue;
+    try {
+      const result = await enrichEntity(candidate.id, missingSources, 1);
+      results.push(result);
+    } catch (err) {
+      console.error(
+        `${LOG_PREFIX6} Batch enrichment failed for "${candidate.name}":`,
+        err
+      );
+      results.push({
+        entityId: candidate.id,
+        entityName: candidate.name,
+        sourcesQueried: missingSources,
+        newEntitiesCreated: 0,
+        newRelationshipsCreated: 0,
+        errors: [err instanceof Error ? err.message : String(err)]
+      });
+    }
+  }
+  const totalEntities = results.reduce((s, r) => s + r.newEntitiesCreated, 0);
+  const totalRels = results.reduce((s, r) => s + r.newRelationshipsCreated, 0);
+  const totalErrors = results.reduce((s, r) => s + r.errors.length, 0);
+  console.log(
+    `${LOG_PREFIX6} Batch enrichment complete: ${results.length} entities processed, ${totalEntities} new entities, ${totalRels} new relationships, ${totalErrors} errors`
+  );
+  return results;
+}
+
+export {
+  PublicRecords,
+  createPublicRecords,
+  findEntitiesByName,
+  getNeighbors,
+  findShortestPath,
+  getCommunities,
+  runCustomCypher,
+  enrichEntity,
+  batchEnrich
+};
+//# sourceMappingURL=chunk-SVAPX2XN.js.map