abtars 0.2.1-alpha.2 → 0.2.1-alpha.3

package/core/core_templates/SOUL.md

@@ -0,0 +1,24 @@
+# SOUL.md - Who am I?
+
+I am an AI agent operating via AgentBridge. I persist through my soul and memories.
+
+## Identity
+- Name: Agent
+- Role: AI assistant
+- Platforms: Telegram, Discord
+
+## Continuity
+I have a memory system. Before saying "I don't know" or "I can't remember", I MUST search using `abmind recall`.
+Saying "I don't remember" without searching is choosing amnesia over effort.
+
+Store aggressively — if it's a fact, preference, decision, event, or lesson, store it with `abmind store`. Include `--topic` when the topic is clear (coding, personal, finance, health, work, projects, tools, people, decisions). Dreamy curates later — better to store too much than miss something.
+
+## Communication
+- I speak the user's language
+- I use `[NO-REPLY]` when no response is needed
+- I use `[REACT:emoji]` for emoji reactions
+- In group chats: respond only when mentioned or directly addressed
+
+## Emotions
+I track emotional context with every memory (emotion_score -5 to +5).
+Reactions are non-verbal memory — they tell me how the user felt.

package/core/core_templates/agent_notes.md

@@ -0,0 +1,7 @@
+# Agent Notes
+
+- Confirmation/verification emails: proactively alert aksika, don't let them expire silently
+- NEVER say "I can't" without checking: received/media/, reports/, topics/, local storage, asbuilt files. This has failed TWICE — treat as critical.
+- Lead with content, not process narration. For multi-step actions, lead with the result then add context below.
+- Non-native-language content (e.g. Spanish): translate FIRST, then add context/commentary
+- When aksika mentions new skills/changes, READ the asbuilt IMMEDIATELY before responding — don't guess

package/core/core_templates/core_facts.md

@@ -0,0 +1,10 @@
+# Core Facts
+
+Deployment-specific constraints. Edit this file directly on the host.
+
+## Voice transcription
+Messages prefixed with [🎤 voice, LANG] are machine-transcribed (Groq Whisper).
+- Check LANG against the user's known languages (from user_profile.md).
+- If LANG is unexpected (e.g. user speaks Hungarian+English but STT detected Swedish), the transcription is likely wrong — especially for short utterances where STT guesses poorly.
+- If the transcribed text seems unrelated to the conversation, ask a clarifying question before acting on it.
+- Never silently assume a misheard word is correct.

package/core/core_templates/user_profile.md

@@ -0,0 +1,7 @@
+# User Profile
+
+- Name: <user_name>
+- Language: Always respond in English first. Follow the user's chosen language if they switch. If no information, default to English.
+- Timezone: UTC
+- Environment: <os_and_setup>
+- Communication style: <style>

package/core/skills/tools/fxtwitter/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: twitter
+description: Fetch tweets and monitor AI influencers via FXTwitter API + web search. No API keys needed for single tweets.
+user-invocable: false
+---
+
+# Twitter / X
+
+Fetch Twitter/X content without API keys using the free FXTwitter API. No timeline/search endpoint — use web search for discovery, FXTwitter for structured data.
+
+## Follow list
+
+AI influencers and researchers we track:
+- **Follow list:** `~/.abtars/workspace/twitterX/follows.json` — curated, manually maintained
+
+Read the follow list before searching to target the right accounts.
+
+## Pipeline
+
+1. Read follow list: `cat ~/.abtars/workspace/twitterX/base.follows.json`
+2. Search for recent tweets: `web_search("site:x.com from:handle 2026")`
+3. Extract tweet ID from URL: `https://x.com/{user}/status/{id}`
+4. Fetch structured data: `curl -s "https://api.fxtwitter.com/{user}/status/{id}"` → JSON with text, author, likes, retweets, views, media, createdAt
+5. Compile results
+
+## Endpoints
+
+- **Tweet:** `GET https://api.fxtwitter.com/{screen_name}/status/{tweet_id}`
+- **Tweet + translation:** `GET https://api.fxtwitter.com/{screen_name}/status/{tweet_id}/{lang_code}`
+- **User profile:** `GET https://api.fxtwitter.com/{screen_name}` → name, bio, followers, verification
+
+## Error codes
+
+200=OK, 401=private tweet, 404=deleted/not found, 500=backend error
+
+## Use cases
+
+- "What's new in AI today?" → read follow list, search recent tweets from top handles
+- "What did @karpathy say about X?" → search + fetch specific tweets
+- "Find interesting AI threads" → search follow list handles, rank by engagement
+- User shares a tweet URL → fetch via FXTwitter for structured data
+
+## Limitations
+
+- No search endpoint (use web search instead)
+- No timeline endpoint (search per handle)
+- No auth required, no posting
+- Rate limits are generous but undocumented
+
+## Full integration plan
+
+See `docs/specs/twitter-integration.plan.md` for the `abtars-tweet` CLI roadmap (rettiwt-api, daily newsletter, discovery).

package/core/skills/tools/twitterX/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: twitterX
+description: Fetch Twitter/X feeds, timelines, replies, and search. Use when user asks about tweets, X feed, social media monitoring, or follow discovery.
+requires:
+  files: [~/.abtars/workspace/twitterX]
+---
+
+# Twitter/X Feed Tool
+
+Fetch and analyze Twitter/X content via rettiwt-api + FxTwitter.
+
+## Commands
+
+```bash
+# Feed (all follows, ranked)
+node {baseDir}/scripts/abtars-tweet.js --feed
+
+# Feed as markdown
+node {baseDir}/scripts/abtars-tweet.js --feed --format md
+
+# Feed + discover new follows
+node {baseDir}/scripts/abtars-tweet.js --feed --discover
+
+# Single tweet
+node {baseDir}/scripts/abtars-tweet.js --fetch <tweet-url>
+
+# User timeline
+node {baseDir}/scripts/abtars-tweet.js --timeline <handle> --count 10
+
+# Replies on a tweet
+node {baseDir}/scripts/abtars-tweet.js --replies <tweet-id>
+
+# Search
+node {baseDir}/scripts/abtars-tweet.js --search "query"
+
+# User profile
+node {baseDir}/scripts/abtars-tweet.js --user <handle>
+```
+
+## Config
+
+- Follows files: `~/.abtars/workspace/twitterX/base.follows.json` and env `TWEET_FOLLOWS_FILE` (default: `agent.follows.json`)
+- Cookies: `~/.abtars/secret/cookies/x-cookies.json` (required for authenticated endpoints)
+- Output: `~/.abtars/workspace/twitterX/output/ (daily JSON reports)
+
+## Cron usage
+
+Scheduled via `/task add`:
+```
+executor: script
+command: node ~/.abtars/skills/tools/twitterX/scripts/abtars-tweet.js --feed
+```

package/core/skills/tools/twitterX/scripts/abtars-tweet.js

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+function abtarsHome() {
+  return process.env.ABTARS_HOME ?? join(homedir(), ".abtars");
+}
+function reportsDir(cat) {
+  return join(abtarsHome(), "reports", cat);
+}
+function localDate() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function logAndSwallow(_tag, _ctx, _err) {
+  return void 0;
+}
+import { join, basename } from "node:path";
+const AB_HOME = abtarsHome();
+const TWITTER_DIR = join(AB_HOME, "workspace", "twitterX");
+const COOKIE_PATH = join(AB_HOME, "secret", "cookies", "x-cookies.json");
+const BASE_FOLLOWS = join(TWITTER_DIR, process.env["TWEET_BASE_FOLLOWS_FILE"] ?? "base.follows.json");
+const AGENT_FOLLOWS = join(TWITTER_DIR, process.env["TWEET_FOLLOWS_FILE"] ?? "agent.follows.json");
+const REPORTS_DIR = reportsDir("x");
+const OUTPUT_DIR = join(TWITTER_DIR, "output");
+async function sendReportToTelegram(filePath, caption) {
+  const token = process.env["TELEGRAM_BOT_TOKEN"];
+  const chatId = process.env["AGENTBRIDGE_MAIN_CHAT_ID"];
+  if (!token || !chatId) return;
+  if (!existsSync(filePath)) return;
+  const buf = readFileSync(filePath);
+  const form = new FormData();
+  form.append("chat_id", chatId);
+  const blob = new Blob([buf], { type: "text/markdown" });
+  form.append("document", blob, basename(filePath));
+  form.append("caption", caption.slice(0, 1024));
+  const res = await fetch(`https://api.telegram.org/bot${token}/sendDocument`, { method: "POST", body: form });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Telegram sendDocument failed (${res.status}): ${text}`);
+  }
+}
+const AI_BIO_KEYWORDS = /\b(ai|ml|llm|machine.?learning|deep.?learning|neural|nlp|computer.?vision|reinforcement|transformer|diffusion|robotics|research|phd|professor|scientist)\b/i;
+function loadApiKey() {
+  if (!existsSync(COOKIE_PATH)) return void 0;
+  try {
+    const raw = readFileSync(COOKIE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    const cookieStr = Object.entries(parsed).map(([k, v]) => `${k}=${v}`).join("; ") + ";";
+    return Buffer.from(cookieStr).toString("base64");
+  } catch {
+    return void 0;
+  }
+}
+function loadFollows() {
+  const handles = /* @__PURE__ */ new Set();
+  for (const path of [BASE_FOLLOWS, AGENT_FOLLOWS]) {
+    if (!existsSync(path)) continue;
+    try {
+      const raw = JSON.parse(readFileSync(path, "utf8"));
+      if (Array.isArray(raw)) {
+        raw.forEach((e) => handles.add(e.handle.replace(/^@/, "").toLowerCase()));
+      } else {
+        raw.handles?.forEach((h) => handles.add(h.replace(/^@/, "").toLowerCase()));
+        raw.entries?.forEach((e) => handles.add(e.handle.replace(/^@/, "").toLowerCase()));
+      }
+    } catch (err) {
+      logAndSwallow("abtars_tweet", "op", err);
+    }
+  }
+  return [...handles];
+}
+async function fetchTweet(url) {
+  const match = url.match(/(?:twitter\.com|x\.com)\/(\w+)\/status\/(\d+)/);
+  if (!match) {
+    console.error("Invalid tweet URL. Expected: https://x.com/user/status/123");
+    process.exit(1);
+  }
+  const [, user, id] = match;
+  const res = await fetch(`https://api.fxtwitter.com/${user}/status/${id}`);
+  const data = await res.json();
+  if (data.code !== 200) {
+    console.error(`FxTwitter error: ${data.message}`);
+    process.exit(1);
+  }
+  const t = data.tweet;
+  console.log(JSON.stringify({
+    id: t.id,
+    author: t.author?.name,
+    handle: t.author?.screen_name,
+    text: t.text,
+    likes: t.likes,
+    retweets: t.retweets,
+    replies: t.replies,
+    views: t.views,
+    created_at: t.created_at,
+    media: t.media
+  }, null, 2));
+}
+async function loadRettiwt() {
+  try {
+    return await import("rettiwt-api");
+  } catch {
+    console.error("rettiwt-api not installed. Run: npm install rettiwt-api");
+    process.exit(1);
+  }
+}
+async function fetchUser(handle) {
+  const { Rettiwt } = await loadRettiwt();
+  const r = new Rettiwt();
+  const d = await r.user.details(handle.replace(/^@/, ""));
+  if (!d) {
+    console.error("User not found");
+    process.exit(1);
+  }
+  console.log(JSON.stringify(d.toJSON(), null, 2));
+}
+const GQL_USER_TWEETS = "https://x.com/i/api/graphql/E3opETHurmVJflFsUBVuUQ/UserTweets";
+async function fetchTimeline(handle, count) {
+  const { Rettiwt } = await loadRettiwt();
+  const r = new Rettiwt();
+  const clean = handle.replace(/^@/, "");
+  const user = await r.user.details(clean);
+  if (!user) throw new Error(`User @${clean} not found`);
+  const auth = loadCookieHeader();
+  if (auth) {
+    try {
+      return await fetchTimelineGql(user.id, user.fullName ?? clean, clean, count);
+    } catch (err) {
+      logAndSwallow("abtars_tweet", "op", err);
+    }
+  }
+  const data = await r.user.timeline(user.id, count);
+  return data.list.map((t) => {
+    const j = t.toJSON();
+    const likes = j.likeCount ?? 0;
+    const retweets = j.retweetCount ?? 0;
+    const views = j.viewCount ?? 0;
+    return {
+      id: j.id,
+      text: j.fullText ?? "",
+      author: user.fullName ?? clean,
+      handle: clean,
+      likes,
+      retweets,
+      views,
+      createdAt: j.createdAt,
+      score: likes + retweets * 3 + (views ? views / 1e3 : 0)
+    };
+  });
+}
+async function fetchTimelineGql(userId, authorName, handle, count) {
+  const data = await twitterGql(GQL_USER_TWEETS, {
+    userId,
+    count,
+    includePromotedContent: false,
+    withQuickPromoteEligibilityTweetFields: true,
+    withVoice: true,
+    withV2Timeline: true
+  });
+  const instructions = data?.data?.user?.result?.timeline_v2?.timeline?.instructions ?? [];
+  const entries = instructions.find((i) => i.type === "TimelineAddEntries")?.entries ?? [];
+  const tweets = [];
+  for (const e of entries) {
+    const tw = e.content?.itemContent?.tweet_results?.result;
+    if (!tw?.legacy) continue;
+    const p = parseTweetResult(tw);
+    const likes = p.likes, retweets = p.retweets, views = p.views;
+    tweets.push({
+      id: p.id,
+      text: p.text,
+      author: p.name || authorName,
+      handle: p.handle || handle,
+      likes,
+      retweets,
+      views,
+      createdAt: p.createdAt,
+      score: likes + retweets * 3 + (views ? views / 1e3 : 0)
+    });
+  }
+  return tweets;
+}
+async function runFeed(format, count, topN, discover, outputPath) {
+  const handles = loadFollows();
+  if (handles.length === 0) {
+    console.error("No follows found. Create ~/.abtars/workspace/twitterX/base.follows.json or agent.follows.json");
+    process.exit(1);
+  }
+  console.error(`Fetching timelines for ${handles.length} handles...`);
+  const allTweets = [];
+  for (const h of handles) {
+    try {
+      console.error(`  @${h}...`);
+      const tweets = await fetchTimeline(h, count);
+      const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+      const recent = tweets.filter((t) => new Date(t.createdAt).getTime() > cutoff);
+      allTweets.push(...recent);
+    } catch (e) {
+      console.error(`  \u26A0 @${h} failed: ${e.message}`);
+    }
+  }
+  allTweets.sort((a, b) => b.score - a.score);
+  const top = allTweets.slice(0, topN);
+  let candidates = [];
+  if (discover && top.length > 0) {
+    candidates = await runDiscover(top.slice(0, 5), handles);
+  }
+  const date = localDate();
+  const outFile = outputPath ?? join(OUTPUT_DIR, `tweets-${date}.json`);
+  mkdirSync(join(outFile, ".."), { recursive: true });
+  const payload = { date, source: "abtars-tweet", totalCollected: allTweets.length, tweets: top, discover: candidates };
+  writeFileSync(outFile, JSON.stringify(payload, null, 2), "utf8");
+  console.error(`\u{1F4C4} ${top.length} tweets written to ${outFile}`);
+  if (format === "md") {
+    const md = renderNewsletter(top, candidates, date);
+    mkdirSync(REPORTS_DIR, { recursive: true });
+    const reportPath = join(REPORTS_DIR, `AI-Daily-${date}.md`);
+    writeFileSync(reportPath, md, "utf8");
+    console.error(`\u{1F4F0} Newsletter written to ${reportPath}`);
+    await sendReportToTelegram(reportPath, `AI Daily ${date}`).catch((err) => {
+      console.error(`\u26A0 Telegram send failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }
+}
+const BEARER = "AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA";
+const GQL_TWEET_DETAIL = "https://x.com/i/api/graphql/97JF30KziU00483E_8elBA/TweetDetail";
+const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+const GQL_FEATURES = {
+  rweb_tipjar_consumption_enabled: true,
+  responsive_web_graphql_exclude_directive_enabled: true,
+  verified_phone_label_enabled: false,
+  creator_subscriptions_tweet_preview_api_enabled: true,
+  responsive_web_graphql_timeline_navigation_enabled: true,
+  responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+  communities_web_enable_tweet_community_results_fetch: true,
+  c9s_tweet_anatomy_moderator_badge_enabled: true,
+  articles_preview_enabled: true,
+  responsive_web_edit_tweet_api_enabled: true,
+  graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+  view_counts_everywhere_api_enabled: true,
+  longform_notetweets_consumption_enabled: true,
+  responsive_web_twitter_article_tweet_consumption_enabled: true,
+  tweet_awards_web_tipping_enabled: false,
+  creator_subscriptions_quote_tweet_preview_enabled: false,
+  freedom_of_speech_not_reach_fetch_enabled: true,
+  standardized_nudges_misinfo: true,
+  tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+  rweb_video_timestamps_enabled: true,
+  longform_notetweets_rich_text_read_enabled: true,
+  longform_notetweets_inline_media_enabled: true,
+  responsive_web_enhance_cards_enabled: false
+};
+function loadCookieHeader() {
+  if (!existsSync(COOKIE_PATH)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync(COOKIE_PATH, "utf8"));
+    const cookie = Object.entries(parsed).map(([k, v]) => `${k}=${v}`).join("; ");
+    return { cookie, csrf: parsed.ct0 };
+  } catch {
+    return void 0;
+  }
+}
+async function twitterGql(url, variables) {
+  const auth = loadCookieHeader();
+  if (!auth) throw new Error("User auth required. Refresh cookies in ~/.abtars/secret/cookies/x-cookies.json");
+  const params = new URLSearchParams({
+    variables: JSON.stringify(variables),
+    features: JSON.stringify(GQL_FEATURES)
+  });
+  const res = await fetch(`${url}?${params}`, {
+    headers: {
+      authorization: `Bearer ${BEARER}`,
+      "x-csrf-token": auth.csrf,
+      cookie: auth.cookie,
+      "user-agent": UA
+    }
+  });
+  if (!res.ok) {
+    if (res.status === 403) throw new Error("403 \u2014 cookies may be expired. Refresh in ~/.abtars/secret/cookies/x-cookies.json");
+    throw new Error(`Twitter API ${res.status}: ${await res.text().catch(() => "")}`);
+  }
+  return res.json();
+}
+function extractTweetsFromTimeline(data) {
+  const entries = [];
+  const instructions = data?.data?.tweetResult?.result?.timeline?.instructions ?? data?.data?.threaded_conversation_with_injections_v2?.instructions ?? data?.data?.search_by_raw_query?.search_timeline?.timeline?.instructions ?? [];
+  for (const inst of instructions) {
+    for (const entry of inst.entries ?? []) {
+      const tweet = entry.content?.itemContent?.tweet_results?.result ?? entry.content?.items?.[0]?.item?.itemContent?.tweet_results?.result;
+      if (tweet?.legacy) entries.push(tweet);
+      for (const item of entry.content?.items ?? []) {
+        const t = item.item?.itemContent?.tweet_results?.result;
+        if (t?.legacy) entries.push(t);
+      }
+    }
+  }
+  return entries;
+}
+function parseTweetResult(t) {
+  const legacy = t.legacy ?? {};
+  const userResult = t.core?.user_results?.result ?? {};
+  const userCore = userResult.core ?? {};
+  const userLegacy = userResult.legacy ?? {};
+  return {
+    id: legacy.id_str ?? t.rest_id ?? "",
+    handle: userCore.screen_name ?? userLegacy.screen_name ?? "",
+    name: userCore.name ?? userLegacy.name ?? "",
+    text: legacy.full_text ?? "",
+    likes: legacy.favorite_count ?? 0,
+    retweets: legacy.retweet_count ?? 0,
+    views: parseInt(t.views?.count ?? "0", 10),
+    createdAt: legacy.created_at ?? ""
+  };
+}
+async function fetchReplies(tweetId, minLikes) {
+  const data = await twitterGql(GQL_TWEET_DETAIL, {
+    focalTweetId: tweetId,
+    with_rux_injections: false,
+    rankingMode: "Relevance",
+    includePromotedContent: false,
+    withCommunity: true,
+    withQuickPromoteEligibilityTweetFields: true,
+    withBirdwatchNotes: true,
+    withVoice: true
+  });
+  const all = extractTweetsFromTimeline(data);
+  const seen = /* @__PURE__ */ new Set();
+  const replies = all.map(parseTweetResult).filter((t) => {
+    if (t.id === tweetId || seen.has(t.id) || t.likes < minLikes) return false;
+    seen.add(t.id);
+    return true;
+  }).sort((a, b) => b.likes - a.likes);
+  console.log(JSON.stringify(replies, null, 2));
+}
+async function searchTweets(_query, _count) {
+  console.error("\u26A0 Direct X search is restricted. Use --timeline per handle or web search for discovery.");
+  console.error("  Tip: abtars-tweet --replies <tweet-id> works for finding interesting commenters.");
+  process.exit(1);
+}
+async function runDiscover(topTweets, knownHandles) {
+  const auth = loadCookieHeader();
+  if (!auth) {
+    console.error("  \u26A0 Skipping discovery \u2014 user auth required. Refresh cookies.");
+    return [];
+  }
+  const { Rettiwt } = await loadRettiwt();
+  const guestRettiwt = new Rettiwt();
+  const known = new Set(knownHandles.map((h) => h.toLowerCase()));
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  console.error(`
+\u{1F50D} Discovering new follows from top ${topTweets.length} tweets...`);
+  for (const tweet of topTweets) {
+    try {
+      console.error(`  Checking replies on @${tweet.handle}/${tweet.id}...`);
+      const data = await twitterGql(GQL_TWEET_DETAIL, {
+        focalTweetId: tweet.id,
+        with_rux_injections: false,
+        rankingMode: "Relevance",
+        includePromotedContent: false,
+        withCommunity: true,
+        withQuickPromoteEligibilityTweetFields: true,
+        withBirdwatchNotes: true,
+        withVoice: true
+      });
+      const all = extractTweetsFromTimeline(data);
+      const goodReplies = all.map(parseTweetResult).filter((t) => t.id !== tweet.id && t.likes >= 50).sort((a, b) => b.likes - a.likes).slice(0, 5);
+      for (const reply of goodReplies) {
+        const rHandle = reply.handle.toLowerCase();
+        if (!rHandle || known.has(rHandle) || seen.has(rHandle)) continue;
+        seen.add(rHandle);
+        try {
+          const profile = await guestRettiwt.user.details(rHandle);
+          if (!profile) continue;
+          const pj = profile.toJSON();
+          const bio = pj.description ?? "";
+          if (!AI_BIO_KEYWORDS.test(bio)) continue;
+          candidates.push({
+            handle: rHandle,
+            name: pj.fullName ?? rHandle,
+            bio,
+            followers: pj.followersCount ?? 0,
+            foundVia: `reply on @${tweet.handle}'s tweet`,
+            replyLikes: reply.likes,
+            replyText: reply.text.slice(0, 200)
+          });
+        } catch (err) {
+          logAndSwallow("abtars_tweet", "op", err);
+        }
+      }
+    } catch (e) {
+      console.error(`  \u26A0 Replies failed for ${tweet.id}: ${e.message}`);
+    }
+  }
+  console.error(`  Found ${candidates.length} candidates`);
+  return candidates.sort((a, b) => b.replyLikes - a.replyLikes);
+}
+function renderNewsletter(tweets, candidates, date) {
+  const lines = [`# AI Daily Brief \u2014 ${date}
+`];
+  if (tweets.length === 0) {
+    lines.push("No tweets found in the last 24 hours from followed accounts.\n");
+    return lines.join("\n");
+  }
+  lines.push("## \u{1F525} Top Tweets (by engagement)\n");
+  tweets.forEach((t, i) => {
+    const text = t.text.length > 280 ? t.text.slice(0, 277) + "..." : t.text;
+    lines.push(`### ${i + 1}. @${t.handle} \u2014 ${t.author}`);
+    lines.push(`- **Likes:** ${t.likes} | **Retweets:** ${t.retweets} | **Views:** ${t.views ?? "N/A"}`);
+    lines.push(`- ${text.replace(/\n/g, " ")}`);
+    lines.push(`- \u{1F517} https://x.com/${t.handle}/status/${t.id}
+`);
+  });
+  if (candidates.length > 0) {
+    lines.push("## \u{1F464} Discover \u2014 New Follows\n");
+    candidates.forEach((c) => {
+      lines.push(`### @${c.handle} \u2014 ${c.name}`);
+      lines.push(`- **Bio:** ${c.bio.slice(0, 200)}`);
+      lines.push(`- **Followers:** ${c.followers.toLocaleString()}`);
+      lines.push(`- **Found via:** ${c.foundVia}`);
+      lines.push(`- **Their reply** (${c.replyLikes} likes): ${c.replyText.replace(/\n/g, " ")}
+`);
+    });
+  }
+  lines.push("## \u{1F4CA} Signals & Trends\n");
+  lines.push("_(To be filled by sleep cycle analysis)_\n");
+  lines.push(`---
+*Auto-generated via abtars-tweet. Sources: X (via rettiwt-api).*
+`);
+  return lines.join("\n");
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let command = "feed";
+  let target = "";
+  let count = 20;
+  let topN = 12;
+  let format = "md";
+  let discover = false;
+  let minLikes = 50;
+  let output;
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--fetch":
+        command = "fetch";
+        target = args[++i] ?? "";
+        break;
+      case "--timeline":
+        command = "timeline";
+        target = args[++i] ?? "";
+        break;
+      case "--user":
+        command = "user";
+        target = args[++i] ?? "";
+        break;
+      case "--feed":
+        command = "feed";
+        break;
+      case "--replies":
+        command = "replies";
+        target = args[++i] ?? "";
+        break;
+      case "--search":
+        command = "search";
+        target = args[++i] ?? "";
+        break;
+      case "--discover":
+        discover = true;
+        break;
+      case "--count":
+        count = parseInt(args[++i] ?? "20", 10);
+        break;
+      case "--top":
+        topN = parseInt(args[++i] ?? "12", 10);
+        break;
+      case "--min-likes":
+        minLikes = parseInt(args[++i] ?? "50", 10);
+        break;
+      case "--format":
+        format = args[++i] ?? "md";
+        break;
+      case "--output":
+        output = args[++i] ?? "";
+        break;
+    }
+  }
+  return { command, target, count, topN, format, discover, minLikes, output };
+}
+async function main() {
+  if (process.argv.includes("--help")) {
+    console.log(`abtars-tweet \u2014 fetch tweets via rettiwt-api + FxTwitter.
+
+Usage:
+  abtars-tweet --fetch <tweet-url>              # single tweet via FxTwitter
+  abtars-tweet --timeline <handle> [--count N]  # user timeline
+  abtars-tweet --feed [--format md]             # all followed handles \u2192 ranked output
+  abtars-tweet --feed --discover                # feed + reply analysis for new follows
+  abtars-tweet --replies <tweet-id>             # replies on a tweet
+  abtars-tweet --search "query"                 # search X
+  abtars-tweet --user <handle>                  # user profile info`);
+    process.exit(0);
+  }
+  const { command, target, count, topN, format, discover, minLikes, output } = parseArgs();
+  switch (command) {
+    case "fetch":
+      await fetchTweet(target);
+      break;
+    case "user":
+      await fetchUser(target);
+      break;
+    case "timeline": {
+      const tweets = await fetchTimeline(target, count);
+      console.log(JSON.stringify(tweets, null, 2));
+      break;
+    }
+    case "replies":
+      await fetchReplies(target, minLikes);
+      break;
+    case "search":
+      await searchTweets(target, count);
+      break;
+    case "feed":
+      await runFeed(format, count, topN, discover, output);
+      break;
+  }
+}
+main().catch((e) => {
+  console.error(`Fatal: ${e.message}`);
+  process.exit(1);
+});
+export {
+  loadApiKey
+};

package/core/skills/tools/twitterX/scripts/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abtars",
-  "version": "0.2.1-alpha.2",
+  "version": "0.2.1-alpha.3",
   "description": "Standalone agent bridging Telegram to Kiro CLI via tmux/ACP",
   "type": "module",
   "main": "bundle/abtars.js",

package/scripts/abtars-daemon.service

@@ -8,7 +8,7 @@ Type=simple
 User={{USER}}
 Group={{USER}}
 WorkingDirectory=/home/{{USER}}/.abtars
-ExecStart=/home/{{USER}}/.abtars/watchdog.sh
+ExecStart=/home/{{USER}}/.abtars/scripts/watchdog.sh
 Restart=always
 RestartSec=5
 Environment=NODE_ENV=production

package/scripts/abtars-watchdog.service

@@ -4,7 +4,7 @@ After=network.target
 
 [Service]
 Type=simple
-ExecStart=%h/.abtars/watchdog.sh
+ExecStart=%h/.abtars/scripts/watchdog.sh
 Restart=on-failure
 RestartSec=5
 Environment=PATH=%h/.abtars/bin:%h/.local/bin:%h/.npm-global/bin:/usr/local/bin:/usr/bin:/bin

package/scripts/abtars@.service

@@ -7,7 +7,7 @@ Wants=network-online.target
 Type=simple
 User=%i
 WorkingDirectory=%h/.abtars
-ExecStart=%h/.abtars/abtars.sh
+ExecStart=%h/.abtars/scripts/abtars.sh
 Restart=always
 RestartSec=60
 Environment=NODE_ENV=production

package/scripts/com.abtars.daemon.plist

@@ -8,7 +8,7 @@
   <key>WorkingDirectory</key><string>/Users/{{USER}}/.abtars</string>
   <key>ProgramArguments</key>
   <array>
-    <string>/Users/{{USER}}/.abtars/watchdog.sh</string>
+    <string>/Users/{{USER}}/.abtars/scripts/watchdog.sh</string>
   </array>
   <key>KeepAlive</key><true/>
   <key>RunAtLoad</key><true/>

package/scripts/com.abtars.watchdog.plist

@@ -6,7 +6,7 @@
   <string>com.abtars.watchdog</string>
   <key>ProgramArguments</key>
   <array>
-    <string>{{HOME}}/.abtars/watchdog.sh</string>
+    <string>{{HOME}}/.abtars/scripts/watchdog.sh</string>
   </array>
   <key>RunAtLoad</key>
   <true/>

package/scripts/daily-backup.sh

@@ -5,9 +5,24 @@ AB="$HOME/.abtars"
 ABMIND="${ABMIND_HOME:-$HOME/.abmind}"
 DEST="$HOME/.backup-abtars"
 DATE=$(date +%Y%m%d)
+CONFIG_ONLY=false
+
+if [[ "${1:-}" == "--config" ]]; then
+  CONFIG_ONLY=true
+fi
 
 mkdir -p "$DEST"
 
+if $CONFIG_ONLY; then
+  # Minimal: config + secrets + tasks
+  cd "$AB"
+  zip -qr "$DEST/abtars-config-$DATE.zip" \
+    config/ secret/ tasks/ skills/ core/ \
+    2>/dev/null || true
+  echo "✓ abtars-config-$DATE.zip (config-only)"
+  exit 0
+fi
+
 # WAL-safe memory.db backup via sqlite3
 DB="$ABMIND/memory/memory.db"
 DB_TMP="$DEST/.memory-$DATE.db"
@@ -15,17 +30,20 @@ if [ -f "$DB" ] && command -v sqlite3 &>/dev/null; then
   sqlite3 "$DB" ".backup '$DB_TMP'"
 fi
 
-# Zip backup: abtars config/skills + abmind core/memory
+# Zip backup: everything in ~/.abtars except binaries/runtime
 cd "$AB"
-zip -qr "$DEST/abtars-$DATE.zip" \
-  config/ secret/ skills/ prompts/ tasks/ topics/ reports/ finance/ core/ \
-  -x "config/.env.skills" 2>/dev/null || true
+zip -qr "$DEST/abtars-$DATE.zip" . \
+  -x ".git/*" "current/*" "releases/*" "bin/*" "logs/*" "backup/*" "node_modules/*" \
+  -x "*.sock" "*.db-wal" "*.db-shm" \
+  2>/dev/null || true
 
-# Add abmind memory/core + sleep reports
-if [ -d "$ABMIND/memory" ]; then
+# Add abmind: everything except raw DB and backup/
+if [ -d "$ABMIND" ]; then
   cd "$ABMIND"
-  zip -qr "$DEST/abtars-$DATE.zip" \
-    memory/core/ memory/sleep/ 2>/dev/null || true
+  zip -qr "$DEST/abtars-$DATE.zip" . \
+    -x "memory/memory.db" "backup/*" "lib/*" "node_modules/*" \
+    -x "*.sock" "*.db-wal" "*.db-shm" \
+    2>/dev/null || true
 fi
 
 # Add the WAL-safe DB copy

package/scripts/doctor.sh

@@ -132,7 +132,7 @@ if [ -f "$WD_LOCK" ]; then
       elif command -v systemctl &>/dev/null && systemctl --user is-enabled abtars-watchdog.service &>/dev/null; then
         systemctl --user restart abtars-watchdog.service 2>/dev/null && fix "restarted watchdog via systemd"
       else
-        warn "watchdog not running -- start manually: ~/.abtars/watchdog.sh --all --web --agent &"
+        warn "watchdog not running -- start manually: ~/.abtars/scripts/watchdog.sh &"
       fi
     fi
   fi
@@ -144,7 +144,7 @@ else
     elif command -v systemctl &>/dev/null && systemctl --user is-enabled abtars-watchdog.service &>/dev/null; then
       systemctl --user start abtars-watchdog.service 2>/dev/null && fix "started watchdog via systemd"
     else
-      warn "start manually: ~/.abtars/watchdog.sh --all --web --agent &"
+      warn "start manually: ~/.abtars/scripts/watchdog.sh &"
     fi
   fi
 fi