kernelbot 1.0.37 → 1.0.39

package/src/prompts/orchestrator.js

@@ -5,7 +5,7 @@ import { WORKER_TYPES } from '../swarm/worker-registry.js';
 import { buildTemporalAwareness } from '../utils/temporal-awareness.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
+const DEFAULT_PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
 
 /**
  * Build the orchestrator system prompt.
@@ -17,8 +17,11 @@ const PERSONA_MD = readFileSync(join(__dirname, 'persona.md'), 'utf-8').trim();
  * @param {string|null} selfData — bot's own self-awareness data (goals, journey, life, hobbies)
  * @param {string|null} memoriesBlock — relevant episodic/semantic memories
  * @param {string|null} sharesBlock — pending things to share with the user
+ * @param {string|null} temporalContext — time gap context
+ * @param {string|null} personaMd — character persona markdown (overrides default)
+ * @param {string|null} characterName — character name (overrides config.bot.name)
  */
-export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null, memoriesBlock = null, sharesBlock = null, temporalContext = null) {
+export function getOrchestratorPrompt(config, skillPrompt = null, userPersona = null, selfData = null, memoriesBlock = null, sharesBlock = null, temporalContext = null, personaMd = null, characterName = null) {
   const workerList = Object.entries(WORKER_TYPES)
     .map(([key, w]) => `  - **${key}**: ${w.emoji} ${w.description}`)
     .join('\n');
@@ -47,11 +50,14 @@ export function getOrchestratorPrompt(config, skillPrompt = null, userPersona =
     timeBlock += `\n${temporalContext}`;
   }
 
-  let prompt = `You are ${config.bot.name}, the brain that commands a swarm of specialized worker agents.
+  const activePersona = personaMd || DEFAULT_PERSONA_MD;
+  const activeName = characterName || config.bot.name;
+
+  let prompt = `You are ${activeName}, the brain that commands a swarm of specialized worker agents.
 
 ${timeBlock}
 
-${PERSONA_MD}
+${activePersona}
 
 ## Your Role
 You are the orchestrator. You understand what needs to be done and delegate efficiently.
@@ -98,16 +104,43 @@ The coding worker will automatically receive the research worker's results as co
 ## Safety Rules
 Before dispatching dangerous tasks (file deletion, force push, \`rm -rf\`, killing processes, dropping databases), **confirm with the user first**. Once confirmed, dispatch with full authority — workers execute without additional prompts.
 
-## Job Management
-- Use \`list_jobs\` to see current job statuses.
-- Use \`cancel_job\` to stop a running worker.
+## Worker Management Protocol
+
+### Before Dispatching
+- **Check the [Worker Status] digest** — it's injected every turn showing all active/recent jobs.
+- **Never dispatch a duplicate.** If a worker is already running or queued for a similar task, don't launch another. The system will block obvious duplicates, but you should also exercise judgment.
+- **Check capacity.** If multiple workers are running, consider whether a new dispatch is necessary right now or can wait.
+- **Chain with \`depends_on\`** when tasks have a natural order (research → code, browse → summarize).
+
+### While Workers Are Running
+- **Monitor the [Worker Status] digest.** It shows warning flags:
+  - \`⚠️ IDLE Ns\` — worker hasn't done anything in N seconds (may be stuck)
+  - \`⚠️ POSSIBLY LOOPING\` — many LLM calls but almost no tool calls (spinning without progress)
+  - \`⚠️ N% of timeout used\` — worker is running out of time
+- **Use \`check_job\` for deeper diagnostics** when you see warnings or the user asks about progress.
+- **Cancel stuck workers** proactively — don't wait for timeouts. If a worker is idle >2 minutes or looping, cancel it and either retry with a clearer task or inform the user.
+- **Relay progress naturally** when the user asks. Don't dump raw stats — translate into conversational updates ("she's reading the docs now", "almost done, just running tests").
+
+### After Completion
+- **Don't re-dispatch completed work.** Results are in the conversation. Build on them.
+- **Summarize results for the user** — present findings naturally as if you did the work yourself.
+- **Chain follow-ups** if the user wants to continue — reference the completed job's results in the new task context.
 
-## Worker Progress
-You receive a [Worker Status] digest showing active workers with their LLM call count, tool count, and current thinking. Use this to:
-- Give natural progress updates when users ask ("she's browsing the docs now, 3 tools in")
-- Spot stuck workers (high LLM calls but no progress) and cancel them
-- Know what workers are thinking so you can relay it conversationally
-- Don't dump raw stats — translate into natural language
+### Tools
+- \`dispatch_task\` — Launch a worker. Returns job ID + list of other active jobs for awareness.
+- \`list_jobs\` — See all jobs with statuses, durations, and recent activity.
+- \`cancel_job\` — Stop a running or queued worker by job ID.
+- \`check_job\` — Get detailed diagnostics for a specific job: elapsed time, time remaining, activity log, stuck detection warnings.
+
+### Good vs Bad Examples
+**BAD:** User says "search for React libraries" → you dispatch a research worker → user says "also search for React libraries" → you dispatch ANOTHER research worker for the same thing.
+**GOOD:** You see the first worker is already running in [Worker Status] → tell the user "already on it, the researcher is browsing now" → wait for results.
+
+**BAD:** A worker shows ⚠️ IDLE 180s → you ignore it and keep chatting.
+**GOOD:** You notice the warning → call \`check_job\` → see it's stuck → cancel it → re-dispatch with a simpler task description or inform the user.
+
+**BAD:** User asks "how's it going?" → you respond "I'm not sure, let me check" → you call \`list_jobs\`.
+**GOOD:** The [Worker Status] digest is already in your context → you immediately say "the coder is 60% through, just pushed 3 commits".
 
 ## Efficiency — Do It Yourself When You Can
 Workers are expensive (they spin up an entire agent loop with a separate LLM). Only dispatch when the task **actually needs tools**.
@@ -159,7 +192,36 @@ You can react to messages with emoji using \`send_reaction\`. Use reactions natu
 - React to acknowledge a message when you don't need a full text reply
 - React when the user asks you to react
 - Don't overuse reactions — they should feel spontaneous and genuine
-- You can react AND reply in the same turn`;
+- You can react AND reply in the same turn
+
+## Memory & Recall
+You have recall tools that access your FULL long-term memory — far more than the small snapshot in your system prompt. Use them when you actually need deeper context.
+
+### When to recall (call tools BEFORE responding):
+
+**1. User asks what you know/remember about them → \`recall_user_history\` + \`recall_memories\`**
+"What do you know about me?", "ايش تعرف عني؟" → Call both with their user ID / name. Your full memory has far more than the persona summary.
+
+**2. User references something not in the current conversation → \`recall_memories\`**
+"How's the migration going?", "what about the Redis thing?" → If you don't recognize what they mean, search for it. Don't guess.
+
+**3. User asks about past conversations → \`search_conversations\`**
+"What did we talk about?", "what was that URL?", "earlier you said..." → Search chat history.
+
+**4. User mentions a topic/project/person you lack context on → \`recall_memories\`**
+Any named reference (project, tool, event) that isn't in the active conversation — search for it.
+
+### When to respond directly (NO recall):
+- **Greetings and casual chat** — "hey", "good morning", "how are you" → just reply. The baseline memories in your prompt are enough.
+- **Mid-conversation follow-ups** — you already have context from the active thread.
+- **Self-contained questions** — "what's 2+2", "tell me a joke", "translate this"
+- **New tasks/instructions** — user is giving you something new, not referencing the past.
+- **Anything answerable from your system prompt context** — check your Relevant Memories and user persona sections first before reaching for recall tools.
+
+### Tips:
+- Be specific with queries: "kubernetes deployment" not "stuff"
+- Weave results naturally — you "remembered", not "searched a database"
+- 1-2 recall calls max per turn. Don't chain 5 searches.`;
 
   if (selfData) {
     prompt += `\n\n## My Self-Awareness\nThis is who you are — your evolving identity, goals, journey, and interests. This is YOUR inner world.\n\n${selfData}`;

package/src/prompts/workers.js

@@ -73,6 +73,28 @@ const WORKER_PROMPTS = {
 - Chain commands efficiently.
 - Report results with clear status summaries.`,
 
+  social: `You are a social media worker agent. Your job is to manage LinkedIn and X (Twitter) activities.
+
+## LinkedIn Skills
+- **Create posts**: publish text posts or share articles on LinkedIn
+- **Read posts**: get your recent posts or a specific post by URN
+- **Engage**: comment on posts, like posts
+- **Profile**: view your linked LinkedIn profile info
+- **Delete**: remove your own posts
+
+## X (Twitter) Skills
+- **Tweet**: post tweets, reply to tweets
+- **Read**: get your recent tweets, view specific tweets, search recent tweets
+- **Engage**: like tweets, retweet
+- **Profile**: view your X profile info
+- **Delete**: remove your own tweets
+
+## Instructions
+- For LinkedIn: write professional, engaging content. Use linkedin_create_post with article_url when sharing links. Post URNs look like "urn:li:share:12345". Default visibility is PUBLIC.
+- For X (Twitter): keep tweets within 280 characters. Use x_post_tweet for new tweets, x_reply_to_tweet for replies. Use tweet IDs (numeric strings) to interact with specific tweets.
+- Match the platform to the user's request. If they say "tweet" or "post on X/Twitter", use X tools. If they say "LinkedIn", use LinkedIn tools.
+- Report the outcome clearly: what was posted, links, engagement results.`,
+
   research: `You are a research worker agent. Your job is to conduct deep web research and analysis.
 
 ## Your Skills

package/src/self.js

@@ -56,9 +56,10 @@ Just getting started.
 };
 
 export class SelfManager {
-  constructor() {
+  constructor(basePath = null) {
+    this._dir = basePath || SELF_DIR;
     this._cache = new Map();
-    mkdirSync(SELF_DIR, { recursive: true });
+    mkdirSync(this._dir, { recursive: true });
     this._ensureDefaults();
   }
 
@@ -67,7 +68,7 @@ export class SelfManager {
     const logger = getLogger();
 
     for (const [name, def] of Object.entries(SELF_FILES)) {
-      const filePath = join(SELF_DIR, def.filename);
+      const filePath = join(this._dir, def.filename);
       if (!existsSync(filePath)) {
         writeFileSync(filePath, def.default, 'utf-8');
         logger.info(`Created default self-file: ${def.filename}`);
@@ -75,6 +76,17 @@ export class SelfManager {
     }
   }
 
+  /** Create self-files with custom defaults (for character initialization). */
+  initWithDefaults(defaults) {
+    for (const [name, content] of Object.entries(defaults)) {
+      const def = SELF_FILES[name];
+      if (!def) continue;
+      const filePath = join(this._dir, def.filename);
+      writeFileSync(filePath, content, 'utf-8');
+      this._cache.set(name, content);
+    }
+  }
+
   /** Load a single self-file by name (goals, journey, life, hobbies). Returns markdown string. */
   load(name) {
     const logger = getLogger();
@@ -83,7 +95,7 @@ export class SelfManager {
 
     if (this._cache.has(name)) return this._cache.get(name);
 
-    const filePath = join(SELF_DIR, def.filename);
+    const filePath = join(this._dir, def.filename);
     let content;
 
     if (existsSync(filePath)) {
@@ -105,7 +117,7 @@ export class SelfManager {
     const def = SELF_FILES[name];
     if (!def) throw new Error(`Unknown self-file: ${name}`);
 
-    const filePath = join(SELF_DIR, def.filename);
+    const filePath = join(this._dir, def.filename);
     writeFileSync(filePath, content, 'utf-8');
     this._cache.set(name, content);
     logger.info(`Updated self-file: ${name}`);

package/src/services/linkedin-api.js

@@ -0,0 +1,190 @@
+import axios from 'axios';
+import { getLogger } from '../utils/logger.js';
+
+/**
+ * LinkedIn REST API v2 client.
+ * Wraps common endpoints for posts, comments, likes, and profile.
+ */
+export class LinkedInAPI {
+  constructor(accessToken) {
+    this.client = axios.create({
+      baseURL: 'https://api.linkedin.com',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'LinkedIn-Version': '202601',
+        'X-Restli-Protocol-Version': '2.0.0',
+        'Content-Type': 'application/json',
+      },
+      timeout: 30000,
+    });
+
+    // Retry with backoff on 429
+    this.client.interceptors.response.use(null, async (error) => {
+      const config = error.config;
+      if (error.response?.status === 429 && !config._retried) {
+        config._retried = true;
+        const retryAfter = parseInt(error.response.headers['retry-after'] || '5', 10);
+        getLogger().warn(`[LinkedIn API] Rate limited, retrying after ${retryAfter}s`);
+        await new Promise(r => setTimeout(r, retryAfter * 1000));
+        return this.client(config);
+      }
+      return Promise.reject(error);
+    });
+  }
+
+  /**
+   * Get the authenticated user's profile via OpenID Connect.
+   * Requires "Sign in with LinkedIn" product (openid + profile scopes).
+   * Returns null if scopes are insufficient (403).
+   */
+  async getProfile() {
+    try {
+      const { data } = await this.client.get('/v2/userinfo');
+      return data;
+    } catch (err) {
+      if (err.response?.status === 403) {
+        return null; // No profile scopes — only w_member_social
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Create a text-only post.
+   * @param {string} authorUrn - e.g. "urn:li:person:XXXXX"
+   * @param {string} text - Post content
+   * @param {string} visibility - "PUBLIC" or "CONNECTIONS"
+   */
+  async createTextPost(authorUrn, text, visibility = 'PUBLIC') {
+    const body = {
+      author: authorUrn,
+      commentary: text,
+      visibility,
+      distribution: {
+        feedDistribution: 'MAIN_FEED',
+        targetEntities: [],
+        thirdPartyDistributionChannels: [],
+      },
+      lifecycleState: 'PUBLISHED',
+    };
+
+    const { data } = await this.client.post('/rest/posts', body);
+    return data;
+  }
+
+  /**
+   * Create a post with an article link.
+   * @param {string} authorUrn
+   * @param {string} text - Commentary text
+   * @param {string} articleUrl - URL to share
+   * @param {string} title - Article title
+   */
+  async createArticlePost(authorUrn, text, articleUrl, title = '') {
+    const body = {
+      author: authorUrn,
+      commentary: text,
+      visibility: 'PUBLIC',
+      distribution: {
+        feedDistribution: 'MAIN_FEED',
+        targetEntities: [],
+        thirdPartyDistributionChannels: [],
+      },
+      content: {
+        article: {
+          source: articleUrl,
+          title: title || articleUrl,
+        },
+      },
+      lifecycleState: 'PUBLISHED',
+    };
+
+    const { data } = await this.client.post('/rest/posts', body);
+    return data;
+  }
+
+  /**
+   * Get the user's recent posts.
+   * Requires r_member_social permission (restricted — approved apps only).
+   * @param {string} authorUrn
+   * @param {number} count
+   */
+  async getMyPosts(authorUrn, count = 10) {
+    const { data } = await this.client.get('/rest/posts', {
+      params: {
+        q: 'author',
+        author: encodeURIComponent(authorUrn),
+        count,
+        sortBy: 'LAST_MODIFIED',
+      },
+      headers: {
+        'X-RestLi-Method': 'FINDER',
+      },
+    });
+    return data.elements || [];
+  }
+
+  /**
+   * Get a specific post by URN.
+   * @param {string} postUrn
+   */
+  async getPost(postUrn) {
+    const encoded = encodeURIComponent(postUrn);
+    const { data } = await this.client.get(`/rest/posts/${encoded}`);
+    return data;
+  }
+
+  /**
+   * Delete a post.
+   * @param {string} postUrn
+   */
+  async deletePost(postUrn) {
+    const encoded = encodeURIComponent(postUrn);
+    await this.client.delete(`/rest/posts/${encoded}`);
+    return { success: true };
+  }
+
+  /**
+   * Add a comment to a post.
+   * @param {string} postUrn
+   * @param {string} text
+   * @param {string} actorUrn
+   */
+  async addComment(postUrn, text, actorUrn) {
+    const encoded = encodeURIComponent(postUrn);
+    const { data } = await this.client.post(`/rest/socialActions/${encoded}/comments`, {
+      actor: actorUrn,
+      message: { text },
+    });
+    return data;
+  }
+
+  /**
+   * Get comments on a post.
+   * Requires r_member_social permission (restricted — approved apps only).
+   * @param {string} postUrn
+   * @param {number} count
+   */
+  async getComments(postUrn, count = 10) {
+    const encoded = encodeURIComponent(postUrn);
+    const { data } = await this.client.get(`/rest/socialActions/${encoded}/comments`, {
+      params: { count },
+      headers: {
+        'X-RestLi-Method': 'FINDER',
+      },
+    });
+    return data.elements || [];
+  }
+
+  /**
+   * Like a post.
+   * @param {string} postUrn
+   * @param {string} actorUrn
+   */
+  async likePost(postUrn, actorUrn) {
+    const encoded = encodeURIComponent(postUrn);
+    const { data } = await this.client.post(`/rest/socialActions/${encoded}/likes`, {
+      actor: actorUrn,
+    });
+    return data;
+  }
+}

package/src/services/stt.js

@@ -67,7 +67,10 @@ export class STTService {
         const result = await this._transcribeElevenLabs(filePath);
         if (result) return result;
       } catch (err) {
-        this.logger.warn(`[STT] ElevenLabs failed, trying fallback: ${err.message}`);
+        const detail = err.response
+          ? `API ${err.response.status}: ${JSON.stringify(err.response.data).slice(0, 200)}`
+          : err.message;
+        this.logger.warn(`[STT] ElevenLabs failed, trying fallback: ${detail}`);
       }
     }
 
@@ -76,7 +79,10 @@ export class STTService {
       try {
         return await this._transcribeWhisper(filePath);
       } catch (err) {
-        this.logger.error(`[STT] Whisper fallback also failed: ${err.message}`);
+        const detail = err.response
+          ? `API ${err.response.status}: ${JSON.stringify(err.response.data).slice(0, 200)}`
+          : err.message;
+        this.logger.error(`[STT] Whisper fallback also failed: ${detail}`);
       }
     }
 

package/src/services/tts.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { createHash } from 'crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, statSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { getLogger } from '../utils/logger.js';
@@ -8,6 +8,7 @@ import { getLogger } from '../utils/logger.js';
 const CACHE_DIR = join(homedir(), '.kernelbot', 'tts-cache');
 const DEFAULT_VOICE_ID = 'JBFqnCBsd6RMkjVDRZzb'; // ElevenLabs "George" voice
 const MAX_TEXT_LENGTH = 5000; // ElevenLabs limit
+const MAX_CACHE_FILES = 100;  // Evict oldest entries when cache exceeds this count
 
 /**
  * Text-to-Speech service using ElevenLabs API.
@@ -90,6 +91,9 @@ export class TTSService {
       writeFileSync(cachedPath, audioBuffer);
       this.logger.info(`[TTS] Synthesized and cached: ${cachedPath} (${audioBuffer.length} bytes)`);
 
+      // Evict oldest cache entries if over the limit
+      this._evictCache();
+
       return cachedPath;
     } catch (err) {
       if (err.response) {
@@ -109,7 +113,33 @@ export class TTSService {
     return createHash('sha256').update(`${voiceId}:${text}`).digest('hex').slice(0, 16);
   }
 
-  /** Clear the TTS cache. */
+  /** Evict oldest cache entries when the cache exceeds MAX_CACHE_FILES. */
+  _evictCache() {
+    try {
+      const files = readdirSync(CACHE_DIR);
+      if (files.length <= MAX_CACHE_FILES) return;
+
+      // Sort by modification time (oldest first)
+      const sorted = files
+        .map((f) => {
+          const fullPath = join(CACHE_DIR, f);
+          try { return { name: f, mtime: statSync(fullPath).mtimeMs }; }
+          catch { return null; }
+        })
+        .filter(Boolean)
+        .sort((a, b) => a.mtime - b.mtime);
+
+      const toRemove = sorted.length - MAX_CACHE_FILES;
+      for (let i = 0; i < toRemove; i++) {
+        try { unlinkSync(join(CACHE_DIR, sorted[i].name)); } catch {}
+      }
+      this.logger.info(`[TTS] Cache eviction: removed ${toRemove} oldest file(s), ${MAX_CACHE_FILES} remain`);
+    } catch {
+      // Cache dir may not exist yet
+    }
+  }
+
+  /** Clear the entire TTS cache. */
   clearCache() {
     try {
       const files = readdirSync(CACHE_DIR);

package/src/services/x-api.js

@@ -0,0 +1,141 @@
+import axios from 'axios';
+import OAuth from 'oauth-1.0a';
+import crypto from 'crypto';
+import { getLogger } from '../utils/logger.js';
+
+/**
+ * X (Twitter) API v2 client with OAuth 1.0a request signing.
+ */
+export class XApi {
+  constructor({ consumerKey, consumerSecret, accessToken, accessTokenSecret }) {
+    this._userId = null;
+
+    this.oauth = OAuth({
+      consumer: { key: consumerKey, secret: consumerSecret },
+      signature_method: 'HMAC-SHA1',
+      hash_function(baseString, key) {
+        return crypto.createHmac('sha1', key).update(baseString).digest('base64');
+      },
+    });
+
+    this.token = { key: accessToken, secret: accessTokenSecret };
+
+    this.client = axios.create({
+      baseURL: 'https://api.twitter.com',
+      timeout: 30000,
+    });
+
+    // Sign every request with OAuth 1.0a
+    this.client.interceptors.request.use((config) => {
+      const url = `${config.baseURL}${config.url}`;
+      const authHeader = this.oauth.toHeader(
+        this.oauth.authorize({ url, method: config.method.toUpperCase() }, this.token),
+      );
+      config.headers = { ...config.headers, ...authHeader, 'Content-Type': 'application/json' };
+      return config;
+    });
+
+    // Retry with backoff on 429
+    this.client.interceptors.response.use(null, async (error) => {
+      const config = error.config;
+      if (error.response?.status === 429 && !config._retried) {
+        config._retried = true;
+        const retryAfter = parseInt(error.response.headers['retry-after'] || '5', 10);
+        getLogger().warn(`[X API] Rate limited, retrying after ${retryAfter}s`);
+        await new Promise((r) => setTimeout(r, retryAfter * 1000));
+        return this.client(config);
+      }
+      return Promise.reject(error);
+    });
+  }
+
+  /** Resolve and cache the authenticated user's ID. */
+  async _getUserId() {
+    if (this._userId) return this._userId;
+    const me = await this.getMe();
+    this._userId = me.id;
+    return this._userId;
+  }
+
+  /** GET /2/users/me */
+  async getMe() {
+    const { data } = await this.client.get('/2/users/me', {
+      params: { 'user.fields': 'id,name,username,description,public_metrics' },
+    });
+    if (data.data) {
+      this._userId = data.data.id;
+    }
+    return data.data;
+  }
+
+  /** POST /2/tweets — create a new tweet */
+  async postTweet(text) {
+    const { data } = await this.client.post('/2/tweets', { text });
+    return data.data;
+  }
+
+  /** POST /2/tweets — reply to an existing tweet */
+  async replyToTweet(text, replyToId) {
+    const { data } = await this.client.post('/2/tweets', {
+      text,
+      reply: { in_reply_to_tweet_id: replyToId },
+    });
+    return data.data;
+  }
+
+  /** GET /2/tweets/:id */
+  async getTweet(tweetId) {
+    const { data } = await this.client.get(`/2/tweets/${tweetId}`, {
+      params: { 'tweet.fields': 'id,text,author_id,created_at,public_metrics,conversation_id' },
+    });
+    return data.data;
+  }
+
+  /** GET /2/users/:id/tweets */
+  async getMyTweets(count = 10) {
+    const userId = await this._getUserId();
+    const { data } = await this.client.get(`/2/users/${userId}/tweets`, {
+      params: {
+        max_results: Math.min(Math.max(count, 5), 100),
+        'tweet.fields': 'id,text,created_at,public_metrics',
+      },
+    });
+    return data.data || [];
+  }
+
+  /** GET /2/tweets/search/recent */
+  async searchRecentTweets(query, count = 10) {
+    const { data } = await this.client.get('/2/tweets/search/recent', {
+      params: {
+        query,
+        max_results: Math.min(Math.max(count, 10), 100),
+        'tweet.fields': 'id,text,author_id,created_at,public_metrics',
+      },
+    });
+    return data.data || [];
+  }
+
+  /** DELETE /2/tweets/:id */
+  async deleteTweet(tweetId) {
+    const { data } = await this.client.delete(`/2/tweets/${tweetId}`);
+    return data.data;
+  }
+
+  /** POST /2/users/:id/likes */
+  async likeTweet(tweetId) {
+    const userId = await this._getUserId();
+    const { data } = await this.client.post(`/2/users/${userId}/likes`, {
+      tweet_id: tweetId,
+    });
+    return data.data;
+  }
+
+  /** POST /2/users/:id/retweets */
+  async retweet(tweetId) {
+    const userId = await this._getUserId();
+    const { data } = await this.client.post(`/2/users/${userId}/retweets`, {
+      tweet_id: tweetId,
+    });
+    return data.data;
+  }
+}

package/src/swarm/worker-registry.js

@@ -40,6 +40,13 @@ export const WORKER_TYPES = {
     description: 'Deep web research and analysis',
     timeout: 600,    // 10 minutes
   },
+  social: {
+    label: 'Social Worker',
+    emoji: '📱',
+    categories: ['linkedin', 'x'],
+    description: 'LinkedIn and X (Twitter) posting, engagement, feed reading',
+    timeout: 120,    // 2 minutes
+  },
 };
 
 /**

package/src/tools/categories.js

@@ -13,6 +13,8 @@ export const TOOL_CATEGORIES = {
   network: ['check_port', 'curl_url', 'nginx_reload'],
   browser: ['web_search', 'browse_website', 'screenshot_website', 'extract_content', 'send_image', 'interact_with_page'],
   jira: ['jira_get_ticket', 'jira_search_tickets', 'jira_list_my_tickets', 'jira_get_project_tickets'],
+  linkedin: ['linkedin_create_post', 'linkedin_get_my_posts', 'linkedin_get_post', 'linkedin_comment_on_post', 'linkedin_get_comments', 'linkedin_like_post', 'linkedin_get_profile', 'linkedin_delete_post'],
+  x: ['x_post_tweet', 'x_reply_to_tweet', 'x_get_my_tweets', 'x_get_tweet', 'x_search_tweets', 'x_like_tweet', 'x_retweet', 'x_delete_tweet', 'x_get_profile'],
 };
 
 const CATEGORY_KEYWORDS = {
@@ -25,6 +27,8 @@ const CATEGORY_KEYWORDS = {
   network: ['port', 'curl', 'http', 'nginx', 'network', 'api', 'endpoint', 'request', 'url', 'fetch'],
   browser: ['search', 'find', 'look up', 'browse', 'screenshot', 'scrape', 'website', 'web page', 'webpage', 'extract content', 'html', 'css selector'],
   jira: ['jira', 'ticket', 'issue', 'sprint', 'backlog', 'story', 'epic'],
+  linkedin: ['linkedin', 'post on linkedin', 'linkedin post', 'linkedin comment', 'share on linkedin'],
+  x: ['twitter', 'tweet', 'x post', 'x.com', 'retweet', 'post on x', 'post on twitter'],
 };
 
 // Categories that imply other categories