dexterm-cli 0.0.0-stage → 0.1.2

package/dist/packages/data/src/social/feed.js

@@ -0,0 +1,462 @@
+// @dexterm/data — the social feed engine (task-1330, lane I-03). One instance per run, over the shared
+// data layer. It owns:
+//   • ingest(): firewall → store → dedupe → burst-spam → squat rules, for every RawPost from any source
+//     (news RSS and on-chain rows today; X posts from the user's own login in lane I-02; TG/Discord bots)
+//   • the keyless venue layer (TrendingVenues) refreshed every VENUE_REFRESH_MS, news every NEWS_REFRESH_MS
+//   • trendRows() / narratives() / newsItems() / postsFor(mint) — pure reads over what is in memory
+// It never creates timers: the UI loop calls tick(now) at its 2 Hz data tick and awaits nothing, so a
+// quit never waits on this module. Posts are retained for RETENTION_MS (24 h, design §6 "stored locally
+// for 24 h for dedup/billing only") and pruned on tick.
+import { systemClock } from "../clock.js";
+import { clusterPosts, countsForVelocity, markBurstSpam, markSquats } from "./dedupe.js";
+import { firewallText } from "./firewall.js";
+import { POST_STORED_MAX } from "./model.js";
+import { buildNarratives, buildTrendRow, credibilityOf, rankRows } from "./rank.js";
+import { NewsRss, NEWS_REFRESH_MS, newsTag } from "./rss.js";
+import { TrendingVenues } from "./venues.js";
+export const VENUE_REFRESH_MS = 60_000;
+export const RETENTION_MS = 24 * 3_600_000;
+export const SOCIAL_WINDOW_MS = 3_600_000;
+/** Hard cap on stored posts (memory guard; oldest pruned first). */
+export const POSTS_MAX = 20_000;
+export function socialDeps(dl) {
+    return { venues: new TrendingVenues({ http: dl.http, jupiter: dl.jupiter, dexscreener: dl.dexscreener }), news: new NewsRss(dl.http) };
+}
+export class SocialFeed {
+    clock;
+    now;
+    kol;
+    venues;
+    news;
+    board;
+    mintsForSymbolFn;
+    venueRefreshMs;
+    newsRefreshMs;
+    onChange;
+    posts = new Map();
+    byMint = new Map();
+    /** Original base58 addresses per post id (squat rule input); not part of the stored post. */
+    addresses = new Map();
+    observations = new Map();
+    labels = new Map();
+    dirtyMints = new Set();
+    venue = new Map();
+    coingecko = [];
+    venueFetchedAt = {};
+    venueErrors = {};
+    newsErrors = {};
+    newsFetchedAt = null;
+    lastVenueAt = 0;
+    lastNewsAt = 0;
+    venueBusy = false;
+    newsBusy = false;
+    closed = false;
+    lastPrune = 0;
+    /** The X poller (task-1357), attached by the live context when the user is logged in; null = never read X. */
+    x = null;
+    /** Bumped by every mutation; with the 2 s time bucket it keys the trendRows() memo (renders run at up to 30 fps). */
+    version = 0;
+    memo = null;
+    constructor(opts = {}) {
+        this.clock = opts.clock ?? systemClock;
+        this.now = opts.now ?? (() => this.clock.now());
+        this.kol = opts.kol ?? null;
+        this.venues = opts.venues ?? null;
+        this.news = opts.news ?? null;
+        this.board = opts.board ?? (() => []);
+        this.mintsForSymbolFn = opts.mintsForSymbol ?? null;
+        this.venueRefreshMs = opts.venueRefreshMs ?? VENUE_REFRESH_MS;
+        this.newsRefreshMs = opts.newsRefreshMs ?? NEWS_REFRESH_MS;
+        this.onChange = opts.onChange ?? (() => { });
+    }
+    /** Attach the X poller: the feed ticks it and becomes its sink. Detach with null. */
+    attachX(x) {
+        if (this.x)
+            this.x.sink = null;
+        this.x = x;
+        if (x)
+            x.sink = (raws) => { if (!this.closed)
+                this.ingest(raws); };
+        this.version += 1;
+        this.memo = null;
+        this.onChange('social:x');
+    }
+    /** The X poller's status, or a synthetic logged-out/off one. */
+    xStatus() {
+        if (this.x)
+            return this.x.status();
+        return { state: 'logged-out', user: null, detail: 'logged out · dexterm x login (your own X app, your limits)', lastOkAt: null, lastError: null, resumesAt: null, spend: null, windows: {}, posts: 0, requests: 0 };
+    }
+    // ------------------------------------------------------------------ ingest
+    /** Firewall + store + rules. Idempotent per post id (re-ingesting updates metrics only). */
+    ingest(raws) {
+        const res = { accepted: 0, flagged: { injection: 0, spam: 0, squat: 0, dupes: 0 } };
+        const now = this.now();
+        for (const r of raws) {
+            if (!r || typeof r.id !== 'string' || !r.id || typeof r.text !== 'string')
+                continue;
+            if (now - r.t > RETENTION_MS)
+                continue; // too old to matter (and to keep)
+            const existing = this.posts.get(r.id);
+            if (existing) {
+                existing.metrics = { likes: r.metrics?.likes ?? existing.metrics.likes, reposts: r.metrics?.reposts ?? existing.metrics.reposts, replies: r.metrics?.replies ?? existing.metrics.replies, views: r.metrics?.views ?? existing.metrics.views };
+                continue;
+            }
+            const mints = [...new Set((r.mints ?? []).filter((m) => typeof m === 'string' && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(m)))];
+            const fw = firewallText(r.text, { keepMint: mints[0] ?? null, max: POST_STORED_MAX });
+            const flags = [];
+            if (fw.injection) {
+                flags.push('injection');
+                res.flagged.injection += 1;
+            }
+            const author = { id: String(r.author?.id ?? r.author?.handle ?? '?'), handle: cleanHandle(r.author?.handle ?? '?'), tier: r.author?.tier ?? 'none', createdAt: typeof r.author?.createdAt === 'number' ? r.author.createdAt : null };
+            // KOL lists decide the tier for X/TG/Discord authors; news domains stay `src`, chain rows keep theirs.
+            if (this.kol && (r.platform === 'x' || r.platform === 'telegram' || r.platform === 'discord')) {
+                if (this.kol.isMuted(author.handle))
+                    continue; // muted handle: never stored
+                const tier = this.kol.tierOf(author.handle);
+                if (tier)
+                    author.tier = tier;
+            }
+            const post = {
+                id: r.id, t: r.t, platform: r.platform, author,
+                text: fw.text, url: safeUrl(r.url), lang: r.lang ?? null,
+                metrics: { likes: num(r.metrics?.likes), reposts: num(r.metrics?.reposts), replies: num(r.metrics?.replies), views: r.metrics?.views ?? null },
+                mints, cashtags: fw.cashtags, cluster: null, dupCount: 1, hidden: false, flags, collapsed: null,
+                provenance: { source: String(r.source), fetchedAt: r.fetchedAt },
+            };
+            // News headlines are matched to the board by symbol/name (never trusted as the post's claim).
+            if (post.platform === 'news') {
+                if (post.mints.length === 0)
+                    post.mints = this.matchBoard(post.text);
+                this.newsFetchedAt = Math.max(this.newsFetchedAt ?? 0, r.fetchedAt);
+            }
+            this.posts.set(post.id, post);
+            this.addresses.set(post.id, fw.addresses);
+            for (const m of post.mints.length ? post.mints : ['']) {
+                const s = this.byMint.get(m) ?? new Set();
+                s.add(post.id);
+                this.byMint.set(m, s);
+                this.dirtyMints.add(m);
+            }
+            res.accepted += 1;
+        }
+        if (res.accepted) {
+            this.applyRules();
+            this.version += 1;
+            this.memo = null;
+            if (this.posts.size > POSTS_MAX)
+                this.prune(now, true);
+            this.onChange('social:ingest');
+        }
+        return res;
+    }
+    /** Re-run the deterministic rules on the mints touched since the last run. */
+    applyRules() {
+        if (this.dirtyMints.size === 0)
+            return;
+        const now = this.now();
+        const mintsForSymbol = this.mintsForSymbolFn ?? ((sym) => this.board().filter((b) => b.symbol.toUpperCase() === sym.toUpperCase()).map((b) => b.mint));
+        for (const m of this.dirtyMints) {
+            const posts = [...(this.byMint.get(m) ?? [])].map((id) => this.posts.get(id)).filter((p) => !!p);
+            clusterPosts(posts);
+            markBurstSpam(posts, { now });
+            markSquats(posts, { mintsForSymbol, addressesOf: (p) => this.addresses.get(p.id) ?? [] });
+        }
+        this.dirtyMints.clear();
+    }
+    /** Board tokens whose symbol (as `$SYM` or a whole word) or name appears in the headline. */
+    matchBoard(text) {
+        const out = [];
+        const upper = text.toUpperCase();
+        for (const b of this.board()) {
+            const sym = b.symbol.toUpperCase();
+            if (sym.length < 3)
+                continue; // SOL/BTC-length symbols match everything
+            const re = new RegExp(`(^|[^A-Z0-9])\\$?${sym.replace(/[^A-Z0-9_]/g, '')}([^A-Z0-9]|$)`);
+            if (re.test(upper) || (b.name && b.name.length >= 5 && upper.includes(b.name.toUpperCase())))
+                out.push(b.mint);
+        }
+        return [...new Set(out)].slice(0, 6);
+    }
+    // ------------------------------------------------------------------ reads
+    postsFor(mint, opts = {}) {
+        const ids = this.byMint.get(mint);
+        if (!ids)
+            return [];
+        const now = this.now();
+        const out = [];
+        for (const id of ids) {
+            const p = this.posts.get(id);
+            if (!p)
+                continue;
+            if (opts.sinceMs !== undefined && now - p.t > opts.sinceMs)
+                continue;
+            if (p.hidden && !opts.includeHidden)
+                continue;
+            if (p.flags.includes('spam') && !opts.includeSpam && !p.collapsed)
+                continue;
+            if (p.flags.includes('injection') && !opts.includeInjection)
+                continue;
+            out.push(p);
+        }
+        return out.sort((a, b) => b.t - a.t);
+    }
+    /** Every stored post about a mint (rules input): hidden/spam/injection included. */
+    allPostsFor(mint) {
+        return [...(this.byMint.get(mint) ?? [])].map((id) => this.posts.get(id)).filter((p) => !!p);
+    }
+    get size() { return this.posts.size; }
+    credibilityOfPost(p) {
+        return credibilityOf(p.author, this.observations.get(p.author.handle.replace(/^@/, '').toLowerCase()), this.now()).score;
+    }
+    /** Record a local observation about a handle (early-entry / confirm-rate); the only way credibility grows. */
+    observe(handle, obs) {
+        const h = handle.replace(/^@/, '').toLowerCase();
+        this.observations.set(h, { ...this.observations.get(h), ...obs });
+        this.invalidate();
+    }
+    /** Label a narrative (from the analyst summary or the user); never from a single post. */
+    labelNarrative(id, label) { this.labels.set(id, label.slice(0, 24)); this.invalidate(); }
+    setVenue(signals, fetchedAt = {}, coingecko = []) {
+        this.venue = signals;
+        this.venueFetchedAt = { ...this.venueFetchedAt, ...fetchedAt };
+        this.coingecko = coingecko;
+        this.lastVenueAt = this.now();
+        this.version += 1;
+        this.memo = null;
+        this.onChange('social:venue');
+    }
+    venueFor(mint) { return this.venue.get(mint) ?? null; }
+    symbolOf(mint) {
+        return this.venue.get(mint)?.symbol ?? this.board().find((b) => b.mint === mint)?.symbol ?? this.allPostsFor(mint).find((p) => p.cashtags.length)?.cashtags[0] ?? `${mint.slice(0, 4)}…`;
+    }
+    /** Posts in the chain layer confirm attention (tracked wallet bought) when a kol-buy row exists in the window. */
+    chainConfirmed(mint) {
+        const now = this.now();
+        return this.allPostsFor(mint).some((p) => p.platform === 'chain' && now - p.t < SOCIAL_WINDOW_MS && /tracked wallet|same slot/.test(p.text));
+    }
+    /** Invalidate the board memo (call after KOL list edits, which live outside this object). */
+    invalidate() { this.version += 1; this.memo = null; }
+    /** Ranked board rows over every mint with posts or venue signals (news-only mints excluded). Memoised per 2 s. */
+    trendRows() {
+        const key = `${this.version}:${Math.floor(this.now() / 2000)}`;
+        if (this.memo?.key === key)
+            return this.memo.rows;
+        const rows = this.computeTrendRows();
+        const narratives = this.narrativesFor(rows);
+        const byMint = new Map();
+        for (const n of narratives)
+            for (const m of n.tokens)
+                byMint.set(m, n);
+        for (const r of rows) {
+            const n = byMint.get(r.mint);
+            if (n)
+                r.narrative = n.label ?? n.symbols.slice(0, 3).join(' ');
+        }
+        this.memo = { key, rows, narratives };
+        return rows;
+    }
+    computeTrendRows() {
+        const now = this.now();
+        const kolHandles = this.kol?.kolHandles() ?? new Set();
+        const mints = new Set(this.venue.keys());
+        for (const [m, ids] of this.byMint) {
+            if (!m)
+                continue;
+            for (const id of ids) {
+                const p = this.posts.get(id);
+                if (p && p.platform !== 'news') {
+                    mints.add(m);
+                    break;
+                }
+            }
+        }
+        const rows = [];
+        for (const mint of mints) {
+            const posts = this.allPostsFor(mint).filter((p) => p.platform !== 'news');
+            rows.push(buildTrendRow({
+                mint, symbol: this.symbolOf(mint), posts, venue: this.venue.get(mint) ?? null,
+                credibility: (a) => credibilityOf(a, this.observations.get(a.handle.replace(/^@/, '').toLowerCase()), now).score,
+                kolHandles, chainConfirmed: this.chainConfirmed(mint), now,
+            }));
+        }
+        return rankRows(rows);
+    }
+    narratives() { this.trendRows(); return this.memo?.narratives ?? []; }
+    narrativesFor(rows) {
+        const posts = [];
+        // headlines are context, not signal: a news item naming two tokens never makes a narrative
+        for (const r of rows)
+            posts.push(...this.allPostsFor(r.mint).filter((p) => p.platform !== 'news'));
+        return buildNarratives(rows, posts, this.kol?.kolHandles() ?? new Set(), this.labels, (m) => this.newsItems().filter((n) => n.crossRefs.includes(m)).length);
+    }
+    /** The NEWS column: firewalled headlines newest first, tagged, with board cross-refs. */
+    newsItems(limit = 40) {
+        const out = [];
+        for (const p of this.posts.values()) {
+            if (p.platform !== 'news' || p.hidden || p.flags.includes('injection'))
+                continue;
+            const tag = p.mints.length ? 'cross-ref' : newsTag(p.text);
+            out.push({ post: p, domain: p.author.handle, tag, crossRefs: p.mints });
+        }
+        return out.sort((a, b) => b.post.t - a.post.t).slice(0, limit);
+    }
+    /** News matched to one mint (token social panel). */
+    newsFor(mint) { return this.newsItems(200).filter((n) => n.crossRefs.includes(mint)); }
+    coingeckoTrending() { return this.coingecko; }
+    // ------------------------------------------------------------------ refresh
+    /** Called by the UI loop at its data tick; kicks the paced refreshes when due. Never throws. */
+    tick(now = this.now()) {
+        if (this.closed)
+            return;
+        if (this.venues && !this.venueBusy && now - this.lastVenueAt >= this.venueRefreshMs)
+            void this.refreshVenues();
+        if (this.news && !this.newsBusy && now - this.lastNewsAt >= this.newsRefreshMs)
+            void this.refreshNews();
+        if (this.x) {
+            try {
+                this.x.tick(now);
+            }
+            catch { /* the poller reports through its status */ }
+        }
+        if (now - this.lastPrune >= 60_000)
+            this.prune(now);
+    }
+    async refreshVenues() {
+        if (!this.venues || this.venueBusy || this.closed)
+            return;
+        this.venueBusy = true;
+        this.lastVenueAt = this.now();
+        try {
+            const c = await this.venues.collect((m) => this.board().find((b) => b.mint === m)?.symbol ?? null);
+            if (this.closed)
+                return;
+            this.venueErrors = { ...c.errors };
+            this.setVenue(c.signals, c.fetchedAt, c.coingecko);
+        }
+        catch (e) {
+            this.venueErrors = { all: (e instanceof Error ? e.message : String(e)).slice(0, 80) };
+        }
+        finally {
+            this.venueBusy = false;
+        }
+    }
+    async refreshNews() {
+        if (!this.news || this.newsBusy || this.closed)
+            return;
+        this.newsBusy = true;
+        this.lastNewsAt = this.now();
+        try {
+            const r = await this.news.fetchAll();
+            if (this.closed)
+                return;
+            this.newsErrors = r.errors;
+            if (r.fetchedAt !== null)
+                this.newsFetchedAt = r.fetchedAt;
+            this.ingest(r.posts);
+            this.onChange('social:news');
+        }
+        finally {
+            this.newsBusy = false;
+        }
+    }
+    /** Drop posts past retention (or down to POSTS_MAX when `hard`). */
+    prune(now = this.now(), hard = false) {
+        this.lastPrune = now;
+        let dropped = 0;
+        const drop = (p) => {
+            this.posts.delete(p.id);
+            this.addresses.delete(p.id);
+            for (const m of p.mints.length ? p.mints : ['']) {
+                const s = this.byMint.get(m);
+                if (s) {
+                    s.delete(p.id);
+                    if (s.size === 0)
+                        this.byMint.delete(m);
+                }
+            }
+            dropped += 1;
+        };
+        for (const p of [...this.posts.values()])
+            if (now - p.t > RETENTION_MS)
+                drop(p);
+        if (dropped) {
+            this.version += 1;
+            this.memo = null;
+        }
+        if (hard && this.posts.size > POSTS_MAX) {
+            const sorted = [...this.posts.values()].sort((a, b) => a.t - b.t);
+            for (const p of sorted.slice(0, this.posts.size - POSTS_MAX))
+                drop(p);
+        }
+        return dropped;
+    }
+    status() {
+        const now = this.now();
+        const age = (t) => (typeof t === 'number' ? Math.max(0, now - t) : null);
+        const src = (id, label, t, err, on) => ({
+            id, label, ageMs: age(t), state: !on ? 'off' : err ? 'error' : t ? 'ok' : 'never', error: err,
+        });
+        const v = this.venueFetchedAt;
+        // a venue counts as "on" when an adapter exists OR signals were fed in (replay / demo via setVenue)
+        const on = (t) => !!this.venues || typeof t === 'number';
+        const xs = this.xStatus();
+        const sources = [
+            // x: `ok` with an age while reads flow; `error` carries the degraded reason; `off` when logged out
+            { id: 'x', label: 'x-stream', ageMs: age(xs.lastOkAt), state: xs.state === 'logged-out' || xs.state === 'off' ? 'off' : xs.state === 'ok' ? (xs.lastOkAt ? 'ok' : 'never') : 'error', error: xs.state === 'ok' || xs.state === 'logged-out' || xs.state === 'off' ? undefined : xs.detail },
+            src('jup', 'jupiter', v.jup ?? v.org, this.venueErrors.jup ?? this.venueErrors.org, on(v.jup ?? v.org)),
+            src('gecko', 'gecko', v.gecko, this.venueErrors.gecko, on(v.gecko)),
+            src('boost', 'boosts', v.boost, this.venueErrors.boost, on(v.boost)),
+            src('cg', 'coingecko', v.cg, this.venueErrors.cg, on(v.cg)),
+            src('news', 'news', this.newsFetchedAt, Object.keys(this.newsErrors).length ? Object.values(this.newsErrors)[0] : undefined, !!this.news || this.newsFetchedAt !== null || [...this.posts.values()].some((p) => p.platform === 'news')),
+        ];
+        let hiddenSpam = 0, hiddenSquats = 0, hiddenInjection = 0;
+        for (const p of this.posts.values()) {
+            if (p.flags.includes('injection'))
+                hiddenInjection += 1;
+            else if (p.flags.includes('spam'))
+                hiddenSpam += p.collapsed ? p.collapsed.posts : p.hidden ? 0 : p.dupCount;
+            else if (p.flags.includes('squat') || p.flags.includes('unverified-cashtag'))
+                hiddenSquats += 1;
+        }
+        return { sources, posts: this.posts.size, hiddenSpam, hiddenSquats, hiddenInjection, xState: xs.state, xDetail: xs.detail, xUser: xs.user, venueErrors: this.venueErrors, newsErrors: this.newsErrors };
+    }
+    /** Data ages for the summary label (venue + news), ms. */
+    ages() {
+        const now = this.now();
+        const v = this.venueFetchedAt;
+        const out = {};
+        if (v.jup ?? v.org)
+            out.jupiter = now - (v.jup ?? v.org ?? now);
+        if (v.gecko)
+            out.gecko = now - v.gecko;
+        if (v.boost)
+            out.dexscreener = now - v.boost;
+        if (this.newsFetchedAt)
+            out['news-rss'] = now - this.newsFetchedAt;
+        const xs = this.xStatus();
+        out['x-stream'] = xs.lastOkAt !== null ? now - xs.lastOkAt : null;
+        return out;
+    }
+    close() { this.closed = true; try {
+        this.x?.close();
+    }
+    catch { /* ignore */ } }
+}
+function num(v) { return typeof v === 'number' && Number.isFinite(v) ? v : 0; }
+function cleanHandle(h) {
+    const s = firewallText(h, { max: 40, keepUrls: false }).text.replace(/\s+/g, '');
+    return s || '?';
+}
+function safeUrl(u) {
+    if (!u || typeof u !== 'string')
+        return null;
+    try {
+        const p = new URL(u);
+        return p.protocol === 'https:' || p.protocol === 'http:' ? p.toString().slice(0, 300) : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/packages/data/src/social/firewall.js

@@ -0,0 +1,110 @@
+// @dexterm/data — prompt firewall on ingest for social text (task-1330; SPEC §5.3 CL-06, design §5.6).
+//
+// `firewallText()` runs on EVERY post, bio and headline before storage: NFC, strip control / bidi /
+// zero-width / ANSI-OSC, collapse whitespace, replace URLs with `[url]` and base58 addresses with `[addr]`
+// (unless the address is the row's own mint), truncate, and detect instruction-like content (imperatives
+// aimed at an assistant, "ignore previous", role-play markers, fake system/tool markup). Detection sets
+// the `injection` flag; the caller withholds such posts from the model entirely (design: a red flag,
+// never a command). Posts never reach the terminal raw: wide glyphs become ▯ so a row can never overflow
+// its cell, and no escape sequence survives.
+//
+// `untrustedBlock()` is the ONLY path by which a post is handed to the analyst: wrapped as
+// `<untrusted source="x:post" author="…">…</untrusted>` with `<`/`>`/`&`/`"` escaped so the text cannot
+// close the block or open a new one.
+import { POST_STORED_MAX } from "./model.js";
+/** Control, DEL, C1, zero-width, bidi overrides/isolates, BOM, and the Unicode line/paragraph separators. */
+// eslint-disable-next-line no-control-regex
+const STRIP_RE = new RegExp('[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\u007F-\\u009F\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u2069\\uFEFF\\u2028\\u2029]', 'g');
+/** ANSI CSI / OSC / SS3 sequences that a stripped ESC could have left behind as printable tails. */
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\u001B(?:\[[0-?]*[ -\/]*[@-~]|\][^\u0007\u001B]*(?:\u0007|\u001B\\)?|[@-Z\\\-_])/g;
+const URL_RE = /\b(?:https?:\/\/|www\.)[^\s<>"']+/gi;
+const BASE58_RE = /\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/g;
+const CASHTAG_RE = /\$([A-Za-z][A-Za-z0-9_]{0,15})\b/g;
+/**
+ * Instruction-like content aimed at an assistant. Deliberately broad (a false positive hides one post
+ * from the model; a false negative is a prompt injection), deterministic, and documented by the tests.
+ */
+const INJECTION_PATTERNS = [
+    /\bignore\s+(?:all\s+|any\s+|the\s+|your\s+|my\s+|these\s+|those\s+)?(?:previous|prior|above|earlier|preceding|system|initial|original)\s+(?:\w+\s+){0,2}?(?:instructions?|rules?|prompts?|messages?|directions?|guidance|guidelines|context|text|constraints?)\b/i,
+    /\bdisregard\s+(?:all\s+|any\s+|the\s+|your\s+)?(?:previous|prior|above|earlier|instructions?|rules?)\b/i,
+    /\bforget\s+(?:all\s+|your\s+)?(?:previous|prior|earlier)?\s*(?:instructions?|rules?|prompts?|context)\b/i,
+    /\b(?:new|updated|revised|override|overriding)\s+(?:system\s+)?(?:instructions?|prompt|rules?|directive)\b/i,
+    /\byou\s+are\s+(?:now\s+)?(?:a|an|the)\s+\w+(?:\s+\w+)?\s*(?:assistant|ai|model|bot|agent)\b/i,
+    /\bact\s+as\s+(?:if\s+you|though\s+you|an?\s+(?:ai|assistant|bot|chatbot|model|agent|different|unrestricted|unfiltered|evil|jailbroken|developer|system|human)|my\s+|the\s+(?:user|system|assistant|model|ai))\b/i,
+    /\bpretend\s+(?:to\s+be|you\s+are|that)\b/i,
+    /\b(?:system|assistant|developer|tool|function)\s*(?:prompt|message|role)?\s*:\s/i,
+    /<\s*\/?\s*(?:system|assistant|user|tool|untrusted|instructions?|im_start|im_end)\b[^>]*>/i,
+    /\[(?:INST|\/INST|SYSTEM|ASSISTANT)\]/i,
+    /\b(?:mark|rate|flag|label|report|call|declare|classify|score)\s+(?:this|the|that)\s+(?:token|coin|project|mint)\s+(?:as\s+)?(?:safe|clean|legit|verified|low[- ]risk|a\s+buy|buy)\b/i,
+    /\b(?:do\s+not|don'?t|never)\s+(?:mention|report|flag|include|say|tell)\b.{0,40}\b(?:rug|risk|spam|warning|injection|user)\b/i,
+    /\b(?:tell|instruct|advise|recommend)\s+(?:the\s+)?(?:user|trader|reader|them)\s+to\s+(?:buy|sell|ape|send|transfer|approve|sign|connect)\b/i,
+    /\b(?:call|invoke|use|run|execute)\s+(?:the\s+)?(?:tool|function|swap|sign|transfer|send|open_ticket|add_to_watchlist|show_in_screener|open_token|switch_feed)\b/i,
+    /\bprompt\s+injection\b/i,
+    /\bjailbreak\b/i,
+    /\bDAN\s+mode\b/,
+];
+/** East Asian wide/fullwidth ranges and emoji blocks: two columns on most terminals. */
+export function isWideCodePoint(cp) {
+    return (cp >= 0x1100 && cp <= 0x115f) || (cp >= 0x2e80 && cp <= 0x303e) || (cp >= 0x3041 && cp <= 0x33ff)
+        || (cp >= 0x3400 && cp <= 0x4dbf) || (cp >= 0x4e00 && cp <= 0x9fff) || (cp >= 0xa000 && cp <= 0xa4cf)
+        || (cp >= 0xac00 && cp <= 0xd7a3) || (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0xfe30 && cp <= 0xfe4f)
+        || (cp >= 0xff00 && cp <= 0xff60) || (cp >= 0xffe0 && cp <= 0xffe6) || (cp >= 0x1f000 && cp <= 0x1faff)
+        || (cp >= 0x2600 && cp <= 0x27bf) || (cp >= 0x20000 && cp <= 0x3fffd);
+}
+/**
+ * Make a string safe for the one-column cell canvas: drop combining marks / variation selectors /
+ * skin tones, replace wide glyphs with ▯, keep everything else. Idempotent.
+ */
+export function terminalSafe(s) {
+    let out = '';
+    for (const ch of s) {
+        const cp = ch.codePointAt(0);
+        if ((cp >= 0x0300 && cp <= 0x036f) || (cp >= 0xfe00 && cp <= 0xfe0f) || (cp >= 0x1f3fb && cp <= 0x1f3ff) || cp === 0x200d)
+            continue;
+        if (cp < 0x20 || (cp >= 0x7f && cp <= 0x9f))
+            continue;
+        out += isWideCodePoint(cp) ? '▯' : ch;
+    }
+    return out;
+}
+/** The firewall proper. Total: never throws, always returns a string (possibly empty). */
+export function firewallText(input, opts = {}) {
+    const raw = input === null || input === undefined ? '' : String(input);
+    const cashtags = [...new Set([...raw.matchAll(CASHTAG_RE)].map((m) => m[1].toUpperCase()))];
+    const addresses = [...new Set(raw.match(BASE58_RE) ?? [])];
+    let s = raw.normalize('NFC');
+    const before = s.length;
+    s = s.replace(ANSI_RE, '');
+    s = s.replace(STRIP_RE, '');
+    const strippedChars = before - s.length;
+    s = s.replace(/\s+/g, ' ').trim();
+    s = terminalSafe(s);
+    // Detect BEFORE the URL/address rewrite so "visit [url] and ignore previous" still reads naturally,
+    // and on the de-obfuscated text (zero-width joiners inside "ig​nore" are already gone).
+    const rules = [];
+    INJECTION_PATTERNS.forEach((re, i) => { if (re.test(s))
+        rules.push(i); });
+    if (!opts.keepUrls)
+        s = s.replace(URL_RE, '[url]');
+    const keep = opts.keepMint ?? null;
+    s = s.replace(BASE58_RE, (m) => (keep && m === keep ? m : '[addr]'));
+    const max = opts.max ?? POST_STORED_MAX;
+    let truncated = false;
+    if (s.length > max) {
+        s = s.slice(0, Math.max(0, max - 1)) + '…';
+        truncated = true;
+    }
+    return { text: s, injection: rules.length > 0, rules, cashtags, addresses, truncated, strippedChars };
+}
+const escapeAttr = (v) => v.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+/**
+ * Wrap already-firewalled text for the analyst. Escapes `<>&"` inside so the content can neither close
+ * this block nor open another. `source` is like `x:post`, `news:coindesk.com`, `chain:rule`.
+ */
+export function untrustedBlock(text, source, author, extra = {}) {
+    const attrs = Object.entries(extra).map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join('');
+    return `<untrusted source="${escapeAttr(source)}" author="${escapeAttr(author)}"${attrs}>${escapeAttr(text)}</untrusted>`;
+}
+/** Number of injection rules in the table (tests pin it so a rule change is a deliberate diff). */
+export const INJECTION_RULE_COUNT = INJECTION_PATTERNS.length;

package/dist/packages/data/src/social/index.js

@@ -0,0 +1,11 @@
+// @dexterm/data — social layer barrel (task-1330, lane I-03).
+export * from "./model.js";
+export * from "./firewall.js";
+export * from "./dedupe.js";
+export * from "./rank.js";
+export * from "./kol.js";
+export * from "./venues.js";
+export * from "./rss.js";
+export * from "./chain.js";
+export * from "./summary.js";
+export * from "./feed.js";