@c4t4/heyamigo 0.9.25 → 0.10.1

package/dist/memory/digest-flag.js

@@ -19,6 +19,14 @@ const KINDS = [
     'SEND-TEXT',
     'CRON',
     'REMIND',
+    'THREAD-NEW',
+    'THREAD-UPDATE',
+    'THREAD-TOUCH',
+    'THREAD-COOL',
+    'THREAD-RESOLVE',
+    'THREAD-DROP',
+    'THREAD-COMPRESS',
+    'THREAD-WEIGHT',
 ];
 // Walk backwards from the end of the string, tracking bracket depth, to find
 // the `[` that matches the final `]`. Returns the tag kind, its payload, and
@@ -82,6 +90,14 @@ export function extractFlags(reply) {
     const sendTexts = [];
     const crons = [];
     const reminds = [];
+    const threadNews = [];
+    const threadUpdates = [];
+    const threadTouches = [];
+    const threadCools = [];
+    const threadResolves = [];
+    const threadDrops = [];
+    const threadCompresses = [];
+    const threadWeights = [];
     while (true) {
         const peeled = peelTrailingTag(current);
         if (!peeled)
@@ -134,6 +150,62 @@ export function extractFlags(reply) {
             else
                 logger.warn({ payload }, 'REMIND tag dropped: unparseable payload');
         }
+        else if (kind === 'THREAD-NEW') {
+            const parsed = parseThreadNewPayload(payload);
+            if (parsed)
+                threadNews.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-NEW tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-UPDATE') {
+            const parsed = parseThreadUpdatePayload(payload);
+            if (parsed)
+                threadUpdates.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-UPDATE tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-TOUCH') {
+            const id = parseThreadId(payload);
+            if (id !== null)
+                threadTouches.unshift({ id });
+            else
+                logger.warn({ payload }, 'THREAD-TOUCH tag dropped: unparseable id');
+        }
+        else if (kind === 'THREAD-COOL') {
+            const parsed = parseThreadCoolPayload(payload);
+            if (parsed)
+                threadCools.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-COOL tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-RESOLVE') {
+            const parsed = parseThreadIdNotePayload(payload);
+            if (parsed)
+                threadResolves.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-RESOLVE tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-DROP') {
+            const parsed = parseThreadIdNotePayload(payload);
+            if (parsed)
+                threadDrops.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-DROP tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-COMPRESS') {
+            const parsed = parseThreadIdNotePayload(payload);
+            if (parsed)
+                threadCompresses.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-COMPRESS tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-WEIGHT') {
+            const parsed = parseThreadWeightPayload(payload);
+            if (parsed)
+                threadWeights.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-WEIGHT tag dropped: unparseable payload');
+        }
     }
     return {
         clean: current,
@@ -145,6 +217,14 @@ export function extractFlags(reply) {
         sendTexts,
         crons,
         reminds,
+        threadNews,
+        threadUpdates,
+        threadTouches,
+        threadCools,
+        threadResolves,
+        threadDrops,
+        threadCompresses,
+        threadWeights,
     };
 }
 // Strip flags that the sender's role isn't permitted to emit. The
@@ -154,6 +234,9 @@ export function filterFlagsByRole(flags, allowedTags) {
     if (allowedTags === 'all' || allowedTags === undefined)
         return flags;
     const allowed = new Set(allowedTags);
+    // 'THREAD' acts as a single allow-all-thread-ops bucket so role
+    // configs don't have to list all 8 THREAD-* variants individually.
+    const threadOk = allowed.has('THREAD');
     return {
         clean: flags.clean,
         digest: allowed.has('DIGEST') ? flags.digest : null,
@@ -164,6 +247,14 @@ export function filterFlagsByRole(flags, allowedTags) {
         sendTexts: allowed.has('SEND-TEXT') ? flags.sendTexts : [],
         crons: allowed.has('CRON') ? flags.crons : [],
         reminds: allowed.has('REMIND') ? flags.reminds : [],
+        threadNews: threadOk ? flags.threadNews : [],
+        threadUpdates: threadOk ? flags.threadUpdates : [],
+        threadTouches: threadOk ? flags.threadTouches : [],
+        threadCools: threadOk ? flags.threadCools : [],
+        threadResolves: threadOk ? flags.threadResolves : [],
+        threadDrops: threadOk ? flags.threadDrops : [],
+        threadCompresses: threadOk ? flags.threadCompresses : [],
+        threadWeights: threadOk ? flags.threadWeights : [],
     };
 }
 // Legacy helper kept so existing callers still compile.
@@ -251,3 +342,134 @@ function parseJournalPayload(payload) {
         return null;
     return { slug, note };
 }
+// ──────────────────────────────────────────────────────────────────
+// THREAD-* payload parsers
+// ──────────────────────────────────────────────────────────────────
+//
+// Two payload shapes:
+//   [THREAD-NEW: key="quoted" key=value]          key/value form
+//   [THREAD-RESOLVE:42 — note]                    id-and-note form
+// Pull `key="quoted-value"` and `key=word-value` pairs out of a
+// payload. Returns a map. Supports backslash-escaped quotes inside
+// quoted values.
+function parseKeyValuePayload(payload) {
+    const out = {};
+    // Quoted values first (greedy enough to capture spaces, escaped quotes)
+    const quotedRe = /\b([a-z_]+)\s*=\s*"((?:[^"\\]|\\.)*)"/gi;
+    let rest = payload;
+    for (const m of payload.matchAll(quotedRe)) {
+        const key = m[1].toLowerCase();
+        const val = m[2].replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+        out[key] = val;
+        rest = rest.replace(m[0], '');
+    }
+    // Then unquoted single-word values
+    const wordRe = /\b([a-z_]+)\s*=\s*(\S+)/gi;
+    for (const m of rest.matchAll(wordRe)) {
+        const key = m[1].toLowerCase();
+        if (key in out)
+            continue;
+        out[key] = m[2];
+    }
+    return out;
+}
+function parseThreadNewPayload(payload) {
+    const kv = parseKeyValuePayload(payload);
+    const title = kv['title']?.trim();
+    const summary = kv['summary']?.trim();
+    if (!title || !summary)
+        return null;
+    const out = { title, summary };
+    if (kv['hotness'] !== undefined) {
+        const n = parseInt(kv['hotness'], 10);
+        if (Number.isFinite(n))
+            out.hotness = n;
+    }
+    if (kv['linked_memory'])
+        out.linkedMemory = kv['linked_memory'];
+    if (kv['category'])
+        out.category = kv['category'].toLowerCase();
+    return out;
+}
+function parseThreadUpdatePayload(payload) {
+    // Leading id, then key=value pairs
+    const idMatch = payload.match(/^\s*(\d+)\b/);
+    if (!idMatch)
+        return null;
+    const id = parseInt(idMatch[1], 10);
+    if (!Number.isFinite(id) || id <= 0)
+        return null;
+    const rest = payload.slice(idMatch[0].length);
+    const kv = parseKeyValuePayload(rest);
+    const out = { id };
+    if (kv['title'])
+        out.title = kv['title'].trim();
+    if (kv['summary'])
+        out.summary = kv['summary'].trim();
+    if (kv['hotness'] !== undefined) {
+        const n = parseInt(kv['hotness'], 10);
+        if (Number.isFinite(n))
+            out.hotness = n;
+    }
+    if (kv['linked_memory'])
+        out.linkedMemory = kv['linked_memory'];
+    return out;
+}
+// `<id>` alone — for TOUCH.
+function parseThreadId(payload) {
+    const m = payload.match(/^\s*(\d+)\s*$/);
+    if (!m)
+        return null;
+    const id = parseInt(m[1], 10);
+    return Number.isFinite(id) && id > 0 ? id : null;
+}
+// `<id> — <note>` shape used by RESOLVE / DROP / COMPRESS. Note is
+// the rest of the payload after the first em/en/hyphen separator.
+const ID_NOTE_SEP_RE = /\s+[—–-]\s+/;
+function parseThreadIdNotePayload(payload) {
+    const idMatch = payload.match(/^\s*(\d+)\b/);
+    if (!idMatch)
+        return null;
+    const id = parseInt(idMatch[1], 10);
+    if (!Number.isFinite(id) || id <= 0)
+        return null;
+    const rest = payload.slice(idMatch[0].length);
+    const sep = rest.match(ID_NOTE_SEP_RE);
+    if (!sep || sep.index === undefined)
+        return { id, note: '' };
+    const note = rest.slice(sep.index + sep[0].length).trim();
+    return { id, note };
+}
+// `<id>` or `<id> — wait Nd|Nh` for COOL.
+function parseThreadCoolPayload(payload) {
+    const idMatch = payload.match(/^\s*(\d+)\b/);
+    if (!idMatch)
+        return null;
+    const id = parseInt(idMatch[1], 10);
+    if (!Number.isFinite(id) || id <= 0)
+        return null;
+    const rest = payload.slice(idMatch[0].length).trim();
+    if (!rest)
+        return { id };
+    // Look for "wait <N><d|h>" anywhere in the rest
+    const waitMatch = rest.match(/wait\s+(\d+)\s*([dh])/i);
+    if (!waitMatch)
+        return { id };
+    const n = parseInt(waitMatch[1], 10);
+    const unit = waitMatch[2].toLowerCase();
+    if (!Number.isFinite(n) || n <= 0)
+        return { id };
+    const deferDays = unit === 'h' ? n / 24 : n;
+    return { id, deferDays };
+}
+// `<category> <weight>` for WEIGHT.
+function parseThreadWeightPayload(payload) {
+    const m = payload.match(/^\s*([a-z0-9][a-z0-9_-]*)\s+(\d+)\s*$/i);
+    if (!m)
+        return null;
+    const category = m[1].toLowerCase();
+    const weight = parseInt(m[2], 10);
+    if (!Number.isFinite(weight))
+        return null;
+    return { category, weight };
+}

package/dist/memory/journals.js

@@ -22,9 +22,6 @@ function journalsIndexPath() {
 function journalObserverStatePath(slug) {
     return resolve(journalDir(slug), 'observer-state.json');
 }
-function journalNudgeStatePath(slug) {
-    return resolve(journalDir(slug), 'nudge-state.json');
-}
 // ---------- low-level fs ----------
 function ensureDirFor(path) {
     mkdirSync(dirname(path), { recursive: true });
@@ -283,24 +280,6 @@ export function setLastScannedTs(slug, jid, ts) {
     state.jids[jid] = { lastScannedTs: ts };
     saveObserverState(slug, state);
 }
-export function loadNudgeState(slug) {
-    const raw = readIfExists(journalNudgeStatePath(slug));
-    if (!raw)
-        return { lastCheckinTs: 0, lastSilentNudgeTs: 0, snoozedUntilTs: 0 };
-    try {
-        const parsed = JSON.parse(raw);
-        return {
-            lastCheckinTs: parsed.lastCheckinTs ?? 0,
-            lastSilentNudgeTs: parsed.lastSilentNudgeTs ?? 0,
-            snoozedUntilTs: parsed.snoozedUntilTs ?? 0,
-        };
-    }
-    catch {
-        return { lastCheckinTs: 0, lastSilentNudgeTs: 0, snoozedUntilTs: 0 };
-    }
-}
-export function saveNudgeState(slug, state) {
-    const path = journalNudgeStatePath(slug);
-    ensureDirFor(path);
-    writeFileSync(path, JSON.stringify(state, null, 2) + '\n', 'utf-8');
-}
+// Nudge-state APIs removed — replaced by the threads watchlist
+// (see src/queue/threads.ts). Existing storage/memory/journals/*/
+// nudge-state.json files become orphaned and can be safely deleted.

package/dist/memory/preamble.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from 'fs';
 import { config } from '../config.js';
 import { getTimezoneForSenderNumber } from '../db/identity-sync.js';
 import { listAsyncTasks } from '../queue/async-tasks.js';
+import { listLiveThreads } from '../queue/threads.js';
 import { readCompressed } from './compressed.js';
 import { buildJournalsPreambleBlock, ensureJournalsScaffold, } from './journals.js';
 import { masterIndexPath, treeIndexPath } from './paths.js';
@@ -14,6 +15,7 @@ import { getRoleForContext } from '../wa/whitelist.js';
 const DIGEST_REMINDER = `[DIGEST: <reason>] at end of reply for durable facts. Sparingly.`;
 const JOURNAL_REMINDER = `[JOURNAL:<slug> — <note>] at end of reply when content fits an active journal. Use listed slugs only.`;
 const ASYNC_REMINDER = `Never call browser_* / mcp__*playwright* tools. Delegate via [ASYNC-BROWSER: <task>]. Non-browser long work → [ASYNC: <task>]. Irreversible writes: gather → confirm → act.`;
+const THREADS_REMINDER = `Threads = your active watchlist. Open new ones with [THREAD-NEW: title="..." summary="..."]. Close with [THREAD-RESOLVE:<id> — note] / [THREAD-DROP:<id> — reason] / [THREAD-COMPRESS:<id> — note]. Touch (mention naturally) with [THREAD-TOUCH:<id>]. Cool/defer with [THREAD-COOL:<id> — wait Nd]. User voice always wins.`;
 // Buildable per-turn so the agent always sees the SENDER's current
 // time. Grammar reference is in cached memory-instructions.md;
 // this is just the live time + format pointer.
@@ -139,6 +141,25 @@ export function buildMemoryPreamble(params) {
         hour12: false,
     }).format(new Date());
     instructions.push(buildSchedulingReminder(nowLocal, senderTz));
+    // Threads — AI-curated relevance watchlist. Off by default; turn on
+    // via config.threads.enabled. Loads up to N hottest live threads
+    // for this chat (default 5) plus a terse pointer to the grammar
+    // (full docs are in cached memory-instructions.md).
+    if (config.threads?.enabled) {
+        const cap = config.threads.preamblePerChat ?? 5;
+        const live = listLiveThreads(params.jid, cap);
+        if (live.length > 0) {
+            const now = Math.floor(Date.now() / 1000);
+            const lines = ['[Live threads — bring up if naturally relevant; don\'t force]'];
+            for (const t of live) {
+                const age = formatAge(Math.max(0, now - t.openedAt));
+                lines.push(`- #${t.id} (hot ${t.hotness}, ${age} ago): ${t.title}`);
+                lines.push(`    ${t.summary}`);
+            }
+            sections.push(lines.join('\n'));
+            instructions.push(THREADS_REMINDER);
+        }
+    }
     // Async tasks in progress for this chat — so the agent doesn't re-promise
     // or contradict work already running. Don't emit another [ASYNC:] for
     // these.

package/dist/memory/scheduler.js

@@ -75,7 +75,6 @@ async function sweep() {
         logger.error({ err }, 'journal observer sweep failed');
     }
 }
-const NUDGE_TICK_MS = 5 * 60 * 1000; // 5 minutes
 let started = false;
 export function startScheduler() {
     if (started)
@@ -111,30 +110,12 @@ export function startScheduler() {
         payload: { handler: 'memory-sweep' },
         recurrence: `@every ${Math.floor(config.memory.sweepIntervalMs / 1000)}s`,
     });
-    // Proactive journal nudges (check-ins, silent-nudges). Migrated from
-    // setInterval to a cron row → orchestrator. Same cadence, same body;
-    // benefits are: survives restarts, visible in `crons` table, can be
-    // paused via control row without code change.
-    registerInternalCronHandler('journal-nudge-tick', runNudgeTickSafe);
-    enqueueCron({
-        name: 'journal-nudge-tick',
-        enqueueInto: 'internal',
-        payload: { handler: 'journal-nudge-tick' },
-        recurrence: `@every ${Math.floor(NUDGE_TICK_MS / 1000)}s`,
-    });
-    logger.info({
-        intervalMs: config.memory.sweepIntervalMs,
-        nudgeTickMs: NUDGE_TICK_MS,
-    }, 'memory scheduler started');
-}
-async function runNudgeTickSafe() {
-    try {
-        const { runNudgeTick } = await import('./journal-nudger.js');
-        await runNudgeTick();
-    }
-    catch (err) {
-        logger.error({ err }, 'nudge tick failed');
-    }
+    // Drop the legacy journal-nudge-tick cron row if it survives from a
+    // pre-threads install. The handler is no longer registered, so any
+    // row left in the table would log warnings every tick. Safe to call
+    // even if the row doesn't exist.
+    deleteCron('journal-nudge-tick');
+    logger.info({ intervalMs: config.memory.sweepIntervalMs }, 'memory scheduler started');
 }
 export function stopScheduler() {
     // All recurring work is now in the crons table; orchestrator handles
@@ -145,10 +126,3 @@ export function stopScheduler() {
     pendingTimers.clear();
     started = false;
 }
-// Exported for callers (CLI, /nudge command) that want to surgically
-// disable nudges without editing config. Use `setCronEnabled` from
-// crons.ts for the on/off switch; this is a hard delete (regenerated
-// on next startScheduler call).
-export function deleteNudgeCron() {
-    return deleteCron('journal-nudge-tick');
-}

package/dist/queue/thread-list.js

@@ -0,0 +1,167 @@
+// /threads chat command handler. Formats listings + handles
+// subcommands: delete, pause, resume, resolve, drop, compress,
+// touch, weight.
+//
+// Phone-readable plain text — same shape as schedule-list.ts.
+import { compressThread, deleteThread, dropThread, getThread, listAllThreads, resolveThread, setThreadEnabled, touchThread, } from './threads.js';
+import { listCategoryWeights, setCategoryWeight, } from './thread-weights.js';
+export function handleThreadsCommand(jid, args) {
+    const sub = args[0]?.toLowerCase();
+    if (!sub) {
+        return formatList(listAllThreads(jid));
+    }
+    // Subcommand: weight <category> <0-100>
+    if (sub === 'weight') {
+        if (args.length === 1)
+            return formatWeights(listCategoryWeights());
+        const category = args[1]?.toLowerCase();
+        const weight = parseInt(args[2] ?? '', 10);
+        if (!category || !Number.isFinite(weight) || weight < 0 || weight > 100) {
+            return 'Usage: /threads weight <category> <0-100>';
+        }
+        setCategoryWeight(category, weight);
+        return `Category "${category}" weight set to ${weight}.`;
+    }
+    // All remaining subcommands take an id as args[1] and optional note as
+    // the rest joined.
+    const id = parseInt(args[1] ?? '', 10);
+    if (!Number.isFinite(id) || id <= 0) {
+        return `Usage: /threads ${sub} <id> [note]`;
+    }
+    const noteTokens = args.slice(2);
+    const note = noteTokens.join(' ').trim();
+    if (sub === 'delete') {
+        return deleteThread(id) ? `Thread #${id} deleted.` : `Thread #${id} not found.`;
+    }
+    if (sub === 'pause') {
+        return setThreadEnabled(id, false)
+            ? `Thread #${id} paused.`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'resume') {
+        return setThreadEnabled(id, true)
+            ? `Thread #${id} resumed.`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'resolve') {
+        const row = resolveThread(id, note || 'manual');
+        return row
+            ? `Thread #${id} resolved: ${row.resolutionNote}`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'drop') {
+        const row = dropThread(id, note || 'manual');
+        return row
+            ? `Thread #${id} dropped: ${row.resolutionNote}`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'compress') {
+        const row = compressThread(id, note || 'manual');
+        return row
+            ? `Thread #${id} compressed: ${row.resolutionNote}`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'touch') {
+        const row = touchThread(id);
+        return row
+            ? `Thread #${id} touched (hotness now ${row.hotness}).`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'show') {
+        const row = getThread(id);
+        return row ? formatOne(row) : `Thread #${id} not found.`;
+    }
+    return [
+        'Usage:',
+        '  /threads                          list all threads in this chat',
+        '  /threads show <id>                show one thread in detail',
+        '  /threads resolve <id> <note>      mark resolved (answer found)',
+        '  /threads drop <id> <reason>       mark dropped (stale)',
+        '  /threads compress <id> <note>     mark moved into cold memory',
+        '  /threads touch <id>               bump hotness manually',
+        '  /threads pause <id>               disable (hide from preamble)',
+        '  /threads resume <id>              re-enable',
+        '  /threads delete <id>              permanent delete',
+        '  /threads weight                   list category weights',
+        '  /threads weight <category> <0-100>  override category weight',
+    ].join('\n');
+}
+function formatList(rows) {
+    if (rows.length === 0)
+        return 'No threads in this chat yet.';
+    const live = rows.filter((r) => r.status === 'live');
+    const closed = rows.filter((r) => r.status !== 'live');
+    const lines = [];
+    if (live.length > 0) {
+        lines.push('*Live threads*');
+        for (const r of live)
+            lines.push(formatRow(r));
+    }
+    if (closed.length > 0) {
+        lines.push('');
+        lines.push('*Closed*');
+        for (const r of closed.slice(0, 10))
+            lines.push(formatRow(r));
+        if (closed.length > 10)
+            lines.push(`  …and ${closed.length - 10} older`);
+    }
+    return lines.join('\n');
+}
+function formatRow(r) {
+    const age = formatAge(Math.floor(Date.now() / 1000) - r.openedAt);
+    const status = r.status === 'live' ? `hot ${r.hotness}` : r.status;
+    const en = r.enabled ? '' : ' [paused]';
+    const cost = formatCost(r.totalInputTokens, r.totalOutputTokens);
+    const costSuffix = cost ? ` · ${cost}` : '';
+    const lines = [`  #${r.id}  ${status}  ${age} ago${en}  ${r.title}${costSuffix}`];
+    if (r.summary)
+        lines.push(`       ${r.summary}`);
+    if (r.resolutionNote)
+        lines.push(`       → ${r.resolutionNote}`);
+    return lines.join('\n');
+}
+function formatOne(r) {
+    const age = formatAge(Math.floor(Date.now() / 1000) - r.openedAt);
+    const lines = [
+        `*Thread #${r.id}* — ${r.title}`,
+        `Status: ${r.status}${r.enabled ? '' : ' (paused)'}`,
+        `Hotness: ${r.hotness}`,
+        `Opened: ${age} ago`,
+        `Last touched: ${formatAge(Math.floor(Date.now() / 1000) - r.lastTouchedAt)} ago`,
+        `Summary: ${r.summary}`,
+    ];
+    if (r.linkedMemory)
+        lines.push(`Linked: ${r.linkedMemory}`);
+    if (r.resolutionNote)
+        lines.push(`Resolution: ${r.resolutionNote}`);
+    const cost = formatCost(r.totalInputTokens, r.totalOutputTokens);
+    if (cost)
+        lines.push(`Cost: ${cost}`);
+    return lines.join('\n');
+}
+function formatWeights(rows) {
+    if (rows.length === 0)
+        return 'No category weights learned yet.';
+    const sorted = [...rows].sort((a, b) => b.weight - a.weight);
+    const lines = ['*Category weights* (higher = AI surfaces more)'];
+    for (const r of sorted) {
+        lines.push(`  ${r.category.padEnd(20)} ${r.weight} (${r.samples} samples)`);
+    }
+    return lines.join('\n');
+}
+function formatAge(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h`;
+    return `${Math.floor(seconds / 86400)}d`;
+}
+function formatCost(input, output) {
+    const total = input + output;
+    if (total === 0)
+        return '';
+    const compact = (n) => n < 1000 ? `${n}` : n < 10_000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+    return `${compact(input)}↑ ${compact(output)}↓`;
+}