peak6-x-intelligence-plugin 0.1.0 → 0.1.1

package/dist/worker.js

@@ -901,7 +901,11 @@ var TOOL_NAMES = {
   getToday: "get-today",
   getAuthorities: "get-authorities",
   suggestHandles: "suggest-handles",
-  trackHandle: "track-handle"
+  trackHandle: "track-handle",
+  analyzeTopic: "analyze-topic",
+  getThread: "get-thread",
+  promoteHandle: "promote-handle",
+  rateTweet: "rate-tweet"
 };
 var ENTITY_TYPES = {
   tweet: "tweet",
@@ -915,7 +919,8 @@ var STATE_KEYS = {
 var EVENT_NAMES = {
   corpusUpdated: "corpus.updated",
   handlePromoted: "handle.promoted",
-  gapIdentified: "gap.identified"
+  gapIdentified: "gap.identified",
+  tweetHighEngagement: "tweet.high-engagement"
 };
 var DEFAULT_CONFIG = {
   company_id: "",
@@ -1017,7 +1022,12 @@ var DEFAULT_CONFIG = {
     },
     tracking_window_days: 14
   },
-  corpus_retention_days: 90
+  corpus_retention_days: 90,
+  engagement_thresholds: {
+    noise_floor: 10,
+    expert: 50,
+    escalation: 100
+  }
 };
 
 // src/pipeline/xai-client.ts
@@ -1181,6 +1191,59 @@ async function verifyTweetExists(http, secrets, bearerRef, tweetId) {
   const data = await response.json();
   return (data.data?.length ?? 0) > 0;
 }
+async function fetchTweetWithConversationId(http, secrets, logger, bearerRef, tweetId) {
+  const bearerToken = await secrets.resolve(bearerRef);
+  const url = `${X_API_BASE}/tweets?ids=${tweetId}&tweet.fields=conversation_id,${TWEET_FIELDS}&expansions=${EXPANSIONS}&user.fields=${USER_FIELDS}`;
+  const response = await http.fetch(url, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${bearerToken}` }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`X API v2 error ${response.status}: ${errorText}`);
+  }
+  const data = await response.json();
+  if (!data.data?.length) {
+    throw new Error(`Tweet ${tweetId} not found`);
+  }
+  const rawTweet = data.data[0];
+  const userMap = /* @__PURE__ */ new Map();
+  if (data.includes?.users) {
+    for (const user of data.includes.users) userMap.set(user.id, user);
+  }
+  const tweet = mapToEnrichedTweet(rawTweet, userMap.get(rawTweet.author_id), "open_discovery");
+  const conversationId = rawTweet.conversation_id ?? tweetId;
+  logger.debug("Fetched tweet with conversation_id", { tweetId, conversationId });
+  return { tweet, conversationId };
+}
+async function fetchConversationTweets(http, secrets, logger, bearerRef, conversationId) {
+  const bearerToken = await secrets.resolve(bearerRef);
+  const query = encodeURIComponent(`conversation_id:${conversationId}`);
+  const url = `${X_API_BASE}/tweets/search/recent?query=${query}&tweet.fields=${TWEET_FIELDS}&expansions=${EXPANSIONS}&user.fields=${USER_FIELDS}&max_results=100`;
+  logger.debug("Fetching conversation tweets", { conversationId });
+  const response = await http.fetch(url, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${bearerToken}` }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger.warn("Conversation search failed", { status: response.status, error: errorText });
+    return [];
+  }
+  const data = await response.json();
+  const userMap = /* @__PURE__ */ new Map();
+  if (data.includes?.users) {
+    for (const user of data.includes.users) userMap.set(user.id, user);
+  }
+  const tweets = [];
+  if (data.data) {
+    for (const tweet of data.data) {
+      tweets.push(mapToEnrichedTweet(tweet, userMap.get(tweet.author_id), "open_discovery"));
+    }
+  }
+  logger.debug("Conversation tweets fetched", { conversationId, count: tweets.length });
+  return tweets;
+}
 
 // src/pipeline/scoring.ts
 function trigrams(text) {
@@ -1253,6 +1316,24 @@ function computeRelevanceScore(tweet, topics) {
   const topicBoost = Math.min(matchCount * 0.1, 0.5);
   return Math.min(0.5 + topicBoost, 1);
 }
+var SINCE_PATTERN = /^(\d+)([hd])$/;
+function parseSince(since) {
+  const match = SINCE_PATTERN.exec(since.trim());
+  if (match) {
+    const amount = parseInt(match[1], 10);
+    const unit = match[2];
+    const ms = unit === "h" ? amount * 36e5 : amount * 864e5;
+    return new Date(Date.now() - ms);
+  }
+  if (/^\d{4}-\d{2}-\d{2}/.test(since)) {
+    const d = new Date(since);
+    return isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+function computeTotalEngagement(metrics) {
+  return metrics.like_count + metrics.retweet_count + metrics.reply_count + metrics.quote_count;
+}
 function scoreTweets(tweets, weights, subWeights, authorityBoost, authorityHandles, authorityByDomain, topics, now) {
   const scoreTime = now ?? /* @__PURE__ */ new Date();
   return tweets.map((tweet) => {
@@ -1556,7 +1637,53 @@ function buildHandleUpdatesFromTweets(tweets, topics, authorityByDomain) {
   return [...handleMap.values()];
 }
 
+// src/pipeline/analyze-topic.ts
+function buildTopicQueries(topic, dateStr) {
+  return [
+    {
+      text: `What are people saying about ${topic} today (${dateStr})? Focus on significant discussions, breaking developments, and notable opinions.`,
+      topic: "core",
+      phase: "open"
+    },
+    {
+      text: `Which experts, analysts, or thought leaders are currently discussing ${topic}? What insights and perspectives are they sharing?`,
+      topic: "expert_voices",
+      phase: "open"
+    },
+    {
+      text: `What problems, complaints, concerns, or risks are people raising about ${topic}? What pain points are being discussed?`,
+      topic: "pain_points",
+      phase: "open"
+    },
+    {
+      text: `What positive developments, innovations, breakthroughs, or success stories related to ${topic} are being shared?`,
+      topic: "positive_signals",
+      phase: "open"
+    },
+    {
+      text: `What articles, research papers, blog posts, or reports about ${topic} are being shared and discussed on X?`,
+      topic: "link_based",
+      phase: "open"
+    }
+  ];
+}
+function crossReferenceCorpus(topic, corpus) {
+  const topicWords = topic.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  const threshold = Math.max(1, Math.ceil(topicWords.length * 0.4));
+  return corpus.filter((tweet) => {
+    const textLower = tweet.text.toLowerCase();
+    const matchCount = topicWords.filter((w) => textLower.includes(w)).length;
+    return matchCount >= threshold;
+  }).sort((a, b) => b.score - a.score);
+}
+
 // src/worker.ts
+function tweetUrl(authorUsername, tweetId) {
+  return `https://x.com/${authorUsername}/status/${tweetId}`;
+}
+function withUrl(tweet) {
+  return { ...tweet, url: tweetUrl(tweet.author_username, tweet.tweet_id) };
+}
 async function getConfig(ctx) {
   const raw = await ctx.config.get();
   return { ...DEFAULT_CONFIG, ...raw };
@@ -1571,6 +1698,7 @@ function buildAuthorityMaps(config) {
   }
   return { allHandles, byDomain };
 }
+var pluginCtx = null;
 async function runDiscoveryPipeline(ctx, job) {
   const config = await getConfig(ctx);
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -1697,6 +1825,24 @@ async function runDiscoveryPipeline(ctx, job) {
     afterDedup: deduplicated.length,
     finalCorpus: corpus.length
   });
+  const engagementThresholds = config.engagement_thresholds ?? DEFAULT_CONFIG.engagement_thresholds;
+  for (const tweet of corpus) {
+    const totalEngagement = computeTotalEngagement(tweet.metrics);
+    if (totalEngagement >= engagementThresholds.escalation) {
+      await ctx.events.emit(EVENT_NAMES.tweetHighEngagement, config.company_id, {
+        tweet_id: tweet.tweet_id,
+        author_username: tweet.author_username,
+        text: tweet.text.slice(0, 280),
+        url: tweetUrl(tweet.author_username, tweet.tweet_id),
+        score: tweet.score,
+        total_engagement: totalEngagement,
+        metrics: tweet.metrics,
+        is_authority: tweet.is_authority,
+        threshold_crossed: "escalation"
+      });
+      await ctx.metrics.write("pipeline.tweet.high_engagement", 1);
+    }
+  }
   for (const tweet of corpus) {
     await ctx.entities.upsert({
       entityType: ENTITY_TYPES.tweet,
@@ -1748,7 +1894,18 @@ async function runDiscoveryPipeline(ctx, job) {
   await ctx.events.emit(EVENT_NAMES.corpusUpdated, config.company_id, {
     date: today,
     corpusSize: corpus.length,
-    topScore: corpus[0]?.score ?? 0
+    topScore: corpus[0]?.score ?? 0,
+    top_items: corpus.slice(0, 5).map((t) => ({
+      tweet_id: t.tweet_id,
+      author_username: t.author_username,
+      score: t.score,
+      text: t.text.slice(0, 140),
+      url: tweetUrl(t.author_username, t.tweet_id),
+      is_authority: t.is_authority
+    })),
+    stats: summary.discovery_stats,
+    authority_count: Object.values(config.authority_lists).reduce((n, l) => n + l.handles.length, 0),
+    handle_candidates: handleStats.discovered
   });
   for (const promo of promotions) {
     if (promo.status === "promoted") {
@@ -1847,25 +2004,34 @@ async function handleSearchCorpus(ctx, params, _runCtx) {
   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 minScore = typeof p.min_score === "number" ? p.min_score : 0;
+  const minEngagement = typeof p.min_engagement === "number" ? p.min_engagement : 0;
+  const since = typeof p.since === "string" ? p.since : void 0;
+  const sinceDate = since ? parseSince(since) : null;
   const tweets = await ctx.entities.list({
     entityType: ENTITY_TYPES.tweet,
-    limit: 200
+    limit: 500
   });
   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);
-    }
+    if (query && !data.text.toLowerCase().includes(query)) continue;
+    if (date && !(data.created_at?.startsWith(date) ?? false)) continue;
+    if (sinceDate && new Date(data.created_at) < sinceDate) continue;
+    if (pillar && !(data.authority_domains?.some((d) => d.toLowerCase().includes(pillar)) ?? false)) continue;
+    if (data.score < minScore) continue;
+    if (minEngagement > 0 && computeTotalEngagement(data.metrics) < minEngagement) continue;
+    results.push(data);
   }
   results.sort((a, b) => b.score - a.score);
-  const limited = results.slice(0, limit);
+  const limited = results.slice(0, limit).map(withUrl);
+  const topLinks = limited.slice(0, 5).map((t) => `- @${t.author_username} (score: ${t.score.toFixed(1)}): ${t.url}`).join("\n");
   return {
-    content: `Found ${limited.length} tweets matching "${query}"`,
+    content: `Found ${limited.length} of ${results.length} tweets matching "${query}"
+
+Top results:
+${topLinks}`,
     data: limited
   };
 }
@@ -1873,27 +2039,38 @@ 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 minScore = typeof p.min_score === "number" ? p.min_score : 0;
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const tweets = await ctx.entities.list({
+    entityType: ENTITY_TYPES.tweet,
+    limit: 500
+  });
+  const results = [];
+  for (const tweet of tweets) {
+    if (tweet.status === "removed" || tweet.status === "archived") continue;
+    const data = tweet.data;
+    if (!data.created_at?.startsWith(today)) continue;
+    if (data.score < minScore) continue;
+    if (pillar && !(data.authority_domains?.some((d) => d.toLowerCase().includes(pillar.toLowerCase())) ?? false)) continue;
+    results.push(data);
+  }
+  results.sort((a, b) => b.score - a.score);
+  const limited = results.slice(0, limit).map(withUrl);
   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
-    );
-  }
+  const topLinks = limited.slice(0, 5).map((t) => `- @${t.author_username} (score: ${t.score.toFixed(1)}): ${t.url}`).join("\n");
   return {
-    content: `Today's corpus: ${summary.total_tweets} tweets. Showing top ${Math.min(limit, items.length)}.`,
+    content: `Today's corpus: ${results.length} tweets total. Showing top ${limited.length}.
+
+Top results:
+${topLinks}`,
     data: {
-      date: summary.date,
-      total: summary.total_tweets,
-      items: items.slice(0, limit),
-      stats: summary.discovery_stats
+      date: today,
+      total: results.length,
+      items: limited,
+      stats: summary?.discovery_stats ?? null
     }
   };
 }
@@ -1967,8 +2144,221 @@ async function handleTrackHandle(ctx, params, _runCtx) {
     content: `Handle @${handle} tracked with relevance ${relevance} in domain "${domain}"`
   };
 }
+async function handleAnalyzeTopic(ctx, params, _runCtx) {
+  const p = params;
+  const topic = typeof p.topic === "string" ? p.topic : "";
+  const includeCorpus = p.include_corpus !== false;
+  if (!topic) return { error: "topic is required" };
+  const config = await getConfig(ctx);
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  await ctx.metrics.write("tool.analyze_topic.invoked", 1);
+  const queries = buildTopicQueries(topic, today);
+  const freshResults = [];
+  let totalCost = 0;
+  for (const query of queries) {
+    try {
+      const result2 = await xaiSearch(
+        ctx.http,
+        ctx.secrets,
+        ctx.logger,
+        config.xai_api_key_ref,
+        { query: query.text, fromDate: today, toDate: today, excludedHandles: config.global_excluded }
+      );
+      freshResults.push({
+        tweet_ids: result2.tweetIds,
+        query_type: query.topic,
+        synthesis_text: result2.synthesisText
+      });
+      totalCost += result2.costUsdTicks;
+    } catch (err) {
+      ctx.logger.warn("Analyze topic sub-query failed", {
+        queryType: query.topic,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  let corpusMatches = [];
+  if (includeCorpus) {
+    const allTweets = await ctx.entities.list({ entityType: ENTITY_TYPES.tweet, limit: 500 });
+    const corpus = allTweets.filter((t) => t.status === "active").map((t) => t.data);
+    corpusMatches = crossReferenceCorpus(topic, corpus);
+  }
+  await ctx.metrics.write("tool.analyze_topic.cost", totalCost / 1e9);
+  const corpusWithUrls = corpusMatches.slice(0, 10).map(withUrl);
+  const result = {
+    topic,
+    synthesis: freshResults.map((r) => `## ${r.query_type}
+${r.synthesis_text}`).join("\n\n"),
+    corpus_matches: corpusWithUrls,
+    fresh_results: freshResults,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const matchLinks = corpusWithUrls.slice(0, 5).map((t) => `- @${t.author_username}: ${t.url}`).join("\n");
+  return {
+    content: `Topic analysis for "${topic}": ${freshResults.length} queries completed, ${corpusMatches.length} corpus matches found.${matchLinks ? `
+
+Top corpus matches:
+${matchLinks}` : ""}`,
+    data: result
+  };
+}
+async function handleGetThread(ctx, params, _runCtx) {
+  const p = params;
+  const tweetId = typeof p.tweet_id === "string" ? p.tweet_id : "";
+  if (!tweetId) return { error: "tweet_id is required" };
+  const config = await getConfig(ctx);
+  await ctx.metrics.write("tool.get_thread.invoked", 1);
+  try {
+    const { tweet, conversationId } = await fetchTweetWithConversationId(
+      ctx.http,
+      ctx.secrets,
+      ctx.logger,
+      config.x_api_bearer_ref,
+      tweetId
+    );
+    const conversationTweets = await fetchConversationTweets(
+      ctx.http,
+      ctx.secrets,
+      ctx.logger,
+      config.x_api_bearer_ref,
+      conversationId
+    );
+    const allThreadTweets = [tweet, ...conversationTweets.filter((t) => t.tweet_id !== tweetId)].map(withUrl);
+    const result = {
+      root_tweet_id: tweetId,
+      conversation_id: conversationId,
+      tweets: allThreadTweets,
+      total_in_conversation: conversationTweets.length + 1
+    };
+    const threadLinks = allThreadTweets.map((t) => `- @${t.author_username}: ${t.url}`).join("\n");
+    return {
+      content: `Thread for tweet ${tweetId}: ${result.tweets.length} tweets in conversation ${conversationId}
+
+${threadLinks}`,
+      data: result
+    };
+  } catch (err) {
+    return {
+      error: `Failed to fetch thread: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function handlePromoteHandle(ctx, params, runCtx) {
+  const p = params;
+  const handle = typeof p.handle === "string" ? p.handle.toLowerCase().replace(/^@/, "") : "";
+  const listName = typeof p.list_name === "string" ? p.list_name : "";
+  const note = typeof p.note === "string" ? p.note : "";
+  if (!handle) return { error: "handle is required" };
+  if (!listName) return { error: "list_name is required" };
+  const config = await getConfig(ctx);
+  if (!config.authority_lists[listName]) {
+    return { error: `Authority list "${listName}" not found. Available: ${Object.keys(config.authority_lists).join(", ")}` };
+  }
+  const existing = await ctx.entities.list({
+    entityType: ENTITY_TYPES.handle,
+    externalId: handle,
+    limit: 1
+  });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing.length > 0) {
+    const record = existing[0];
+    const data = record.data;
+    await ctx.entities.upsert({
+      entityType: ENTITY_TYPES.handle,
+      scopeKind: "instance",
+      externalId: handle,
+      title: handle,
+      status: "promoted",
+      data: {
+        ...data,
+        promoted_to_list: listName,
+        notes: note ? `${data.notes ? data.notes + "; " : ""}Promoted to ${listName}: ${note}` : data.notes
+      }
+    });
+  } else {
+    const data = {
+      first_seen: now.split("T")[0],
+      last_seen: now.split("T")[0],
+      appearances: 0,
+      avg_relevance: 0,
+      domains: [listName],
+      followed_by_existing: [],
+      followers_count: 0,
+      sample_tweet_ids: [],
+      promoted_to_list: listName,
+      notes: note ? `Manually promoted to ${listName}: ${note}` : `Manually promoted to ${listName}`
+    };
+    await ctx.entities.upsert({
+      entityType: ENTITY_TYPES.handle,
+      scopeKind: "instance",
+      externalId: handle,
+      title: handle,
+      status: "promoted",
+      data
+    });
+  }
+  await ctx.events.emit(EVENT_NAMES.handlePromoted, config.company_id, {
+    handle,
+    list_name: listName,
+    promoted_by: runCtx.agentId ?? "manual",
+    note
+  });
+  await ctx.activity.log({
+    companyId: config.company_id,
+    message: `Handle @${handle} promoted to authority list "${listName}"`,
+    metadata: { list_name: listName, note }
+  });
+  return {
+    content: `Handle @${handle} promoted to authority list "${listName}"`
+  };
+}
+async function handleRateTweet(ctx, params, runCtx) {
+  const p = params;
+  const tweetId = typeof p.tweet_id === "string" ? p.tweet_id : "";
+  const rating = typeof p.rating === "string" ? p.rating : "";
+  const ratedBy = typeof p.rated_by === "string" ? p.rated_by : runCtx.agentId ?? "unknown";
+  if (!tweetId) return { error: "tweet_id is required" };
+  if (!["relevant", "irrelevant", "skip"].includes(rating)) {
+    return { error: 'rating must be "relevant", "irrelevant", or "skip"' };
+  }
+  const existing = await ctx.entities.list({
+    entityType: ENTITY_TYPES.tweet,
+    externalId: tweetId,
+    limit: 1
+  });
+  if (existing.length === 0) {
+    return { error: `Tweet ${tweetId} not found in corpus` };
+  }
+  const record = existing[0];
+  const data = record.data;
+  const existingRatings = Array.isArray(data.ratings) ? data.ratings : [];
+  const newRating = {
+    rated_by: ratedBy,
+    rated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    value: rating
+  };
+  await ctx.entities.upsert({
+    entityType: ENTITY_TYPES.tweet,
+    scopeKind: "instance",
+    externalId: tweetId,
+    title: record.title ?? tweetId,
+    status: record.status ?? "active",
+    data: {
+      ...data,
+      ratings: [...existingRatings, newRating]
+    }
+  });
+  await ctx.metrics.write("tool.rate_tweet.invoked", 1);
+  const data2 = record.data;
+  const ratedUrl = data2.author_username ? tweetUrl(data2.author_username, tweetId) : `https://x.com/i/status/${tweetId}`;
+  return {
+    content: `Tweet ${tweetId} rated as "${rating}" by ${ratedBy}. Total ratings: ${existingRatings.length + 1}
+${ratedUrl}`
+  };
+}
 var plugin = definePlugin({
   async setup(ctx) {
+    pluginCtx = 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));
@@ -1998,6 +2388,26 @@ var plugin = definePlugin({
       { displayName: "Track Handle", description: "Record a handle appearance", parametersSchema: {} },
       (params, runCtx) => handleTrackHandle(ctx, params, runCtx)
     );
+    ctx.tools.register(
+      TOOL_NAMES.analyzeTopic,
+      { displayName: "Analyze Topic", description: "On-demand xAI topic analysis with 5-perspective decomposition and corpus cross-reference", parametersSchema: {} },
+      (params, runCtx) => handleAnalyzeTopic(ctx, params, runCtx)
+    );
+    ctx.tools.register(
+      TOOL_NAMES.getThread,
+      { displayName: "Get Tweet Thread", description: "Fetch conversation context for a tweet", parametersSchema: {} },
+      (params, runCtx) => handleGetThread(ctx, params, runCtx)
+    );
+    ctx.tools.register(
+      TOOL_NAMES.promoteHandle,
+      { displayName: "Promote Handle", description: "Promote a handle to authority status in a specific list", parametersSchema: {} },
+      (params, runCtx) => handlePromoteHandle(ctx, params, runCtx)
+    );
+    ctx.tools.register(
+      TOOL_NAMES.rateTweet,
+      { displayName: "Rate Tweet", description: "Record relevance feedback on a corpus tweet", parametersSchema: {} },
+      (params, runCtx) => handleRateTweet(ctx, params, runCtx)
+    );
     ctx.data.register("dashboard-summary", async () => {
       const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       const summary = await ctx.state.get({
@@ -2028,6 +2438,57 @@ var plugin = definePlugin({
     ctx.data.register("plugin-config", async () => {
       return await ctx.config.get();
     });
+    ctx.data.register("corpus-browser", async (params) => {
+      const p = params;
+      const date = typeof p.date === "string" ? p.date : (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const pillar = typeof p.pillar === "string" ? p.pillar : void 0;
+      const minScore = typeof p.min_score === "number" ? p.min_score : 0;
+      const minEngagement = typeof p.min_engagement === "number" ? p.min_engagement : 0;
+      const authorityOnly = p.authority_only === true;
+      const page = typeof p.page === "number" ? p.page : 1;
+      const pageSize = typeof p.page_size === "number" ? p.page_size : 25;
+      const allTweets = await ctx.entities.list({
+        entityType: ENTITY_TYPES.tweet,
+        limit: 500
+      });
+      const filtered = [];
+      for (const tweet of allTweets) {
+        if (tweet.status === "removed" || tweet.status === "archived") continue;
+        const data = tweet.data;
+        if (!data.created_at?.startsWith(date)) continue;
+        if (data.score < minScore) continue;
+        if (pillar && !(data.authority_domains?.some((d) => d.toLowerCase().includes(pillar.toLowerCase())) ?? false)) continue;
+        if (minEngagement > 0 && computeTotalEngagement(data.metrics) < minEngagement) continue;
+        if (authorityOnly && !data.is_authority) continue;
+        filtered.push(data);
+      }
+      filtered.sort((a, b) => b.score - a.score);
+      const totalCount = filtered.length;
+      const totalPages = Math.ceil(totalCount / pageSize) || 1;
+      const start = (page - 1) * pageSize;
+      const items = filtered.slice(start, start + pageSize).map(withUrl);
+      const dates = [];
+      for (let i = 0; i < 7; i++) {
+        const d = /* @__PURE__ */ new Date();
+        d.setDate(d.getDate() - i);
+        dates.push(d.toISOString().split("T")[0]);
+      }
+      const config = await getConfig(ctx);
+      const result = {
+        items,
+        pagination: { page, pageSize, totalCount, totalPages },
+        filters: {
+          date,
+          pillar: pillar ?? null,
+          minScore,
+          minEngagement,
+          authorityOnly
+        },
+        available_pillars: config.content_pillars,
+        available_dates: dates
+      };
+      return result;
+    });
     let discoveryRunning = false;
     ctx.actions.register("trigger-discovery", async () => {
       if (discoveryRunning) {
@@ -2049,7 +2510,66 @@ var plugin = definePlugin({
     ctx.logger.info("X Intelligence plugin initialized");
   },
   async onHealth() {
-    return { status: "ok", message: "X Intelligence plugin is running" };
+    if (!pluginCtx) return { status: "error", message: "Plugin not initialized" };
+    try {
+      const config = await getConfig(pluginCtx);
+      const lastRun = await pluginCtx.state.get({
+        scopeKind: "instance",
+        stateKey: STATE_KEYS.lastDiscoveryRun
+      });
+      const now = /* @__PURE__ */ new Date();
+      const lastRunDate = lastRun?.generatedAt ? new Date(lastRun.generatedAt) : null;
+      const hoursSinceLastRun = lastRunDate ? (now.getTime() - lastRunDate.getTime()) / (1e3 * 60 * 60) : null;
+      const status = hoursSinceLastRun === null ? "degraded" : hoursSinceLastRun > 36 ? "degraded" : "ok";
+      return {
+        status,
+        message: lastRun ? `Last discovery: ${lastRun.date} (${Math.round(hoursSinceLastRun)}h ago)` : "No discovery runs yet",
+        details: {
+          lastDiscoveryRun: lastRun?.date ?? null,
+          hoursSinceLastRun: hoursSinceLastRun ? Math.round(hoursSinceLastRun) : null,
+          configuredTopics: config.semantic_topics.length,
+          configuredAuthorities: Object.keys(config.authority_lists).length
+        }
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        message: `Health check failed: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  },
+  async onValidateConfig(config) {
+    const warnings = [];
+    const errors = [];
+    const xaiRef = config.xai_api_key_ref;
+    const xRef = config.x_api_bearer_ref;
+    if (!xaiRef) errors.push("xai_api_key_ref is required");
+    if (!xRef) errors.push("x_api_bearer_ref is required");
+    if (pluginCtx && xaiRef) {
+      try {
+        const key = await pluginCtx.secrets.resolve(xaiRef);
+        if (!key || key.length < 10) warnings.push("xAI API key appears invalid (too short)");
+      } catch {
+        errors.push(`Cannot resolve xAI API key secret: ${xaiRef}`);
+      }
+    }
+    if (pluginCtx && xRef) {
+      try {
+        const key = await pluginCtx.secrets.resolve(xRef);
+        if (!key || key.length < 10) warnings.push("X API bearer token appears invalid (too short)");
+      } catch {
+        errors.push(`Cannot resolve X API bearer secret: ${xRef}`);
+      }
+    }
+    const sw = config.scoring_weights;
+    if (sw) {
+      const sum = (sw.relevance ?? 0) + (sw.recency ?? 0) + (sw.engagement ?? 0);
+      if (Math.abs(sum - 1) > 0.05) warnings.push(`Scoring weights sum to ${sum.toFixed(2)}, expected ~1.0`);
+    }
+    if (config.semantic_topics?.length === 0) {
+      warnings.push("No semantic topics configured \u2014 discovery will produce no results");
+    }
+    return { ok: errors.length === 0, warnings, errors };
   }
 });
 var worker_default = plugin;