dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/cli/src/ledger-cmd.js

@@ -0,0 +1,288 @@
+// `dexterm ledger <sub>` (task-1530): the unified TRADE LEDGER. One row per round trip from every place dexterm books a
+// trade: the paper ticket (paper wallet), the agent paper desk (its journal), autotrade runs (their hash-chained run
+// ledgers) and the live signer (its trade ledger). Each row carries the strategy id + version + hash, the declared exit
+// profile and entry reason (and where each came from), the exit reason, size and % of book, entry / exit price AND
+// market cap, fees, impact, hold, rug flag, wallet mode and the model sessions that made it.
+//
+// Reads never write: every command folds $DEXTERM_HOME/ledger/trades.jsonl plus what the sources hold that the file
+// does not yet (shown as "pending"). `sync` appends those to the file (append-only, sha256-chained; a broken file is
+// refused, never rewritten) and `verify` recomputes the chain. No network, no model, no key, no signer.
+import { writeFileSync } from 'node:fs';
+export const LEDGER_HELP = `dexterm ledger: the unified trade ledger (paper, agent paper desk, autotrade runs, live). Read-only unless sync.
+
+  dexterm ledger trades     [filters] [--limit N] [--json]   one row per round trip, newest first
+  dexterm ledger positions  [filters] [--json]               the open trades (cost, % of book, held, profile)
+  dexterm ledger summary    [filters] [--json]               win rate (95% interval), P/L, drawdown, rug rate, by profile / exit / strategy / source / mode
+  dexterm ledger equity     [filters] [--json]               the realized equity curve and its max drawdown
+  dexterm ledger compare    [filters] [--json]               one row per strategy version: the forward-test table
+  dexterm ledger export csv|json|parquet-lite [filters] [--out FILE]   (or --format csv|json|parquet-lite)
+  dexterm ledger card <tradeId> [--square] [--price] [--exact] [--sol-usd N]   a PnL card (market cap at entry / exit)
+  dexterm ledger sync [--json]                                append what the sources hold to the ledger file
+  dexterm ledger verify [--json]                              recompute the ledger file's sha256 chain
+
+  filters: --source paper|desk|autotrade|live  --mode paper|devnet|live  --strategy ID[@VERSION|@HASH]  --profile P
+           --exit REASON  --mint MINT  --run RUN_ID  --account ID  --days N  --status open|closed  --wallet-db PATH
+
+  The file is $DEXTERM_HOME/ledger/trades.jsonl (default ~/.dexterm). PAPER rows are simulated; filter by --mode
+  before comparing results. Not financial advice.`;
+const VALUE_FLAGS = new Set(['source', 'mode', 'strategy', 'profile', 'exit', 'mint', 'run', 'account', 'days', 'status', 'limit', 'out', 'sol-usd', 'wallet-db', 'format']);
+function parse(argv) {
+    const o = { _: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a.startsWith('--')) {
+            o._.push(a);
+            continue;
+        }
+        const eq = a.indexOf('=');
+        const k = eq > 0 ? a.slice(2, eq) : a.slice(2);
+        if (VALUE_FLAGS.has(k)) {
+            const v = eq > 0 ? a.slice(eq + 1) : argv[++i];
+            if (v === undefined || v === '')
+                return `--${k} needs a value`;
+            o[k] = v;
+        }
+        else
+            o[k] = true;
+    }
+    return o;
+}
+/** CLI flags → the MCP tool args shape, validated by the same filterFromArgs the ledger tools use. */
+async function filterOf(o, now) {
+    const { filterFromArgs } = await import('../../mcp/src/index.js');
+    const a = {};
+    for (const [flag, key] of [['source', 'source'], ['mode', 'mode'], ['strategy', 'strategy'], ['profile', 'profile'], ['exit', 'exit_reason'], ['mint', 'mint'], ['run', 'run_id'], ['account', 'account'], ['status', 'status']]) {
+        if (typeof o[flag] === 'string')
+            a[key] = o[flag];
+    }
+    if (typeof o.days === 'string')
+        a.days = Number(o.days);
+    return filterFromArgs(a, now);
+}
+async function loadView(io, o, now) {
+    const at = await import('../../autotrade/src/index.js');
+    return at.loadLedgerView({ env: io.env, now, ...(typeof o['wallet-db'] === 'string' ? { walletDb: o['wallet-db'] } : {}) });
+}
+// ───────────────────────────── formatting ─────────────────────────────
+const pad = (s, n) => (s.length >= n ? s.slice(0, n) : s + ' '.repeat(n - s.length));
+const lpad = (s, n) => (s.length >= n ? s : ' '.repeat(n - s.length) + s);
+const num = (x, d = 2) => (x === null || x === undefined || !Number.isFinite(x) ? '—' : x.toFixed(d));
+const pct = (x) => (x === null || x === undefined || !Number.isFinite(x) ? '—' : `${x >= 0 ? '+' : ''}${x.toFixed(1)}%`);
+const frac = (x) => (x === null || x === undefined ? '—' : `${(x * 100).toFixed(0)}%`);
+export function fmtCap(v) {
+    if (v === null || v === undefined || !Number.isFinite(v))
+        return '—';
+    if (v >= 1e9)
+        return `$${(v / 1e9).toFixed(2)}B`;
+    if (v >= 1e6)
+        return `$${(v / 1e6).toFixed(2)}M`;
+    if (v >= 1e3)
+        return `$${(v / 1e3).toFixed(1)}K`;
+    return `$${v.toFixed(0)}`;
+}
+const hold = (sec) => (sec < 90 ? `${Math.round(sec)}s` : sec < 5400 ? `${Math.round(sec / 60)}m` : sec < 172800 ? `${(sec / 3600).toFixed(1)}h` : `${(sec / 86400).toFixed(1)}d`);
+const when = (t) => new Date(t).toISOString().slice(0, 16).replace('T', ' ');
+const stratOf = (t) => (t.strategy ? `${t.strategy.id}@${t.strategy.version ?? (t.strategy.hash ?? '').slice(0, 8)}` : 'manual');
+const tagOf = (id, source) => (id ? (source === 'structured' || source === 'rule' ? id : `${id}*`) : '—');
+function banner(v, rows) {
+    const out = [];
+    const f = v.file;
+    out.push(f.exists ? (f.check.ok ? `ledger ${v.path}: ${f.events.length} events, chain verified` : `ledger ${v.path}: FAILS its check at line ${f.check.at}: ${f.check.error}`) : `ledger ${v.path}: not written yet (\`dexterm ledger sync\` writes it)`);
+    if (v.pending.length)
+        out.push(`  + ${v.pending.length} events from the sources not in the file yet (shown here; \`dexterm ledger sync\` appends them)`);
+    for (const s of v.sources)
+        if (s.problem)
+            out.push(`  ! ${s.problem}`);
+    const modes = [...new Set(rows.map((t) => t.walletMode))];
+    if (modes.length > 1)
+        out.push('  PAPER, DEVNET and LIVE trades are mixed here: use --mode before comparing results.');
+    else if (modes[0] === 'paper')
+        out.push('  PAPER (simulated) trades.');
+    return out;
+}
+function tradesTable(rows) {
+    const head = `${pad('opened', 16)}  ${pad('symbol', 8)} ${pad('src', 9)} ${pad('mode', 6)} ${pad('strategy', 18)} ${pad('profile', 10)} ${pad('exit', 14)} ${lpad('size', 8)} ${lpad('%book', 6)} ${lpad('entry mc', 9)} ${lpad('exit mc', 9)} ${lpad('P/L', 8)} ${lpad('hold', 6)} ${lpad('MFE', 7)} ${lpad('MAE', 7)}  id`;
+    const out = [head];
+    for (const t of rows) {
+        const size = t.sizeSol !== null ? `${num(t.sizeSol, 3)}◎` : t.sizeUsd !== null ? `$${num(t.sizeUsd, 0)}` : '—';
+        out.push([
+            pad(when(t.openedAt), 16), ' ', pad(t.symbol, 8), ' ', pad(t.source, 9), ' ', pad(t.walletMode, 6), ' ', pad(stratOf(t), 18), ' ',
+            pad(tagOf(t.profile.id, t.profile.source), 10), ' ', pad(t.status === 'open' ? 'open' : `${t.exitReason.code ?? 'untagged'}${t.rug ? ' RUG' : ''}`, 14), ' ',
+            lpad(size, 8), ' ', lpad(t.pctOfBook === null ? '—' : `${t.pctOfBook.toFixed(0)}%`, 6), ' ', lpad(fmtCap(t.entryMcapUsd), 9), ' ', lpad(fmtCap(t.exitMcapUsd), 9), ' ',
+            lpad(t.status === 'open' ? '—' : pct(t.pnlPct), 8), ' ', lpad(hold(t.holdSec), 6), ' ', lpad(pct(t.mfePct), 7), ' ', lpad(pct(t.maePct), 7), '  ', t.tradeId,
+        ].join(''));
+    }
+    return out;
+}
+// ───────────────────────────── subcommands ─────────────────────────────
+export async function ledgerCommand(argv, io) {
+    const sub = argv[0];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        io.stdout.write(`${LEDGER_HELP}\n`);
+        return 0;
+    }
+    const o = parse(argv.slice(1));
+    if (typeof o === 'string') {
+        io.stderr.write(`dexterm ledger: ${o}\n`);
+        return 2;
+    }
+    const now = Date.now();
+    const json = o.json === true;
+    const out = (s) => io.stdout.write(s.endsWith('\n') ? s : `${s}\n`);
+    try {
+        if (sub === 'verify') {
+            const { readTradeLedger, tradeLedgerPath } = await import('../../data/src/trade/ledger/index.js');
+            const path = tradeLedgerPath(io.env);
+            const r = readTradeLedger(path);
+            if (json)
+                out(JSON.stringify({ path, exists: r.exists, ...r.check }));
+            else if (!r.exists)
+                out(`${path}: not written yet (nothing to verify)`);
+            else
+                out(r.check.ok ? `${path}: ${r.check.events} events, chain verified, head ${r.check.head.slice(0, 16)}` : `${path}: FAILS at line ${r.check.at}: ${r.check.error}`);
+            return r.exists && !r.check.ok ? 1 : 0;
+        }
+        if (sub === 'sync') {
+            const at = await import('../../autotrade/src/index.js');
+            const r = at.syncLedger({ env: io.env, now, ...(typeof o['wallet-db'] === 'string' ? { walletDb: o['wallet-db'] } : {}) });
+            const problems = r.view.sources.filter((s) => s.problem).map((s) => s.problem);
+            if (json)
+                out(JSON.stringify({ path: r.view.path, added: r.added, skipped: r.skipped, events: r.events, head: r.head, sources: r.view.sources }));
+            else {
+                out(`${r.view.path}: +${r.added} events (${r.skipped} already there), ${r.events} total, head ${r.head.slice(0, 16)}`);
+                for (const s of r.view.sources)
+                    out(`  ${pad(s.source, 9)} ${s.label}: ${s.events} source events, ${s.pending} new${s.note ? ` · ${s.note}` : ''}`);
+                for (const p of problems)
+                    out(`  ! ${p}`);
+            }
+            return 0;
+        }
+        const fr = await filterOf(o, now);
+        if (!fr.ok) {
+            io.stderr.write(`dexterm ledger: ${fr.error}\n`);
+            return 2;
+        }
+        const { filterTrades, summarize, equityCurve, compareStrategies, exportTrades, EXPORT_FORMATS } = await import('../../data/src/trade/ledger/index.js');
+        const v = await loadView(io, o, now);
+        const filter = sub === 'positions' ? { ...fr.filter, status: 'open' } : fr.filter;
+        const rows = filterTrades(v.trades, filter).sort((a, b) => b.openedAt - a.openedAt);
+        switch (sub) {
+            case 'trades':
+            case 'positions': {
+                const limit = typeof o.limit === 'string' ? Math.max(1, Math.min(10_000, Number.parseInt(o.limit, 10) || 50)) : sub === 'positions' ? 10_000 : 50;
+                const shown = rows.slice(0, limit);
+                if (json) {
+                    out(JSON.stringify({ count: rows.length, trades: shown }));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                if (!rows.length) {
+                    out(sub === 'positions' ? 'no open trades' : 'no trades match');
+                    return 0;
+                }
+                for (const l of tradesTable(shown))
+                    out(l);
+                out(`${shown.length} of ${rows.length} shown · profile/exit with * = not declared structurally (tag line, late, default)`);
+                return 0;
+            }
+            case 'summary': {
+                const s = summarize(rows);
+                if (json) {
+                    out(JSON.stringify(s));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                const u = s.unit === 'SOL' ? '◎' : '$';
+                out(`trades ${s.trades} closed · ${s.open} open · wins ${s.wins} · losses ${s.losses}`);
+                out(`win rate ${s.winRate ? `${frac(s.winRate.value)} (95% ${frac(s.winRate.lo)}–${frac(s.winRate.hi)})` : '—'} · P/L ${num(s.pnl, s.unit === 'SOL' ? 3 : 2)}${u} · avg ${pct(s.avgPnlPct)} · median ${pct(s.medianPnlPct)} · best ${pct(s.bestPct)} · worst ${pct(s.worstPct)}`);
+                out(`profit factor ${num(s.profitFactor)} · max drawdown ${num(s.maxDrawdown, 3)}${u}${s.maxDrawdownPct !== null ? ` (${num(s.maxDrawdownPct, 1)}%)` : ''} · rugs ${s.rugs} (${frac(s.rugRate)}) · avg hold ${s.avgHoldSec === null ? '—' : hold(s.avgHoldSec)} · MFE ${pct(s.avgMfePct)} · MAE ${pct(s.avgMaePct)}`);
+                out(`fees ${num(s.feesSol, 4)}◎ · model cost $${num(s.modelCostUsd)} · declared profile ${frac(s.tagCoverage.profileDeclared)} · declared exit ${frac(s.tagCoverage.exitDeclared)}`);
+                for (const [title, gs] of [['by profile', s.byProfile], ['by exit reason', s.byExitReason], ['by strategy', s.byStrategy], ['by source', s.bySource], ['by mode', s.byMode]]) {
+                    if (!gs.length)
+                        continue;
+                    out(`\n${title}`);
+                    for (const g of gs)
+                        out(`  ${pad(g.key, 22)} ${lpad(String(g.trades), 4)} closed ${lpad(String(g.open), 3)} open  win ${lpad(frac(g.winRate), 4)}  P/L ${lpad(num(g.pnl, s.unit === 'SOL' ? 3 : 2), 9)}${u}  avg ${lpad(pct(g.avgPnlPct), 7)}  rugs ${g.rugs}`);
+                }
+                if (s.trades < 30)
+                    out(`\n${s.trades} closed trades: a small sample says little (see the interval).`);
+                return 0;
+            }
+            case 'equity': {
+                const c = equityCurve(rows);
+                if (json) {
+                    out(JSON.stringify(c));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                const u = c.unit === 'SOL' ? '◎' : '$';
+                out(`realized equity (${c.unit}), ${c.points.length} closes · final ${num(c.final, 3)}${u} · max drawdown ${num(c.maxDrawdown, 3)}${u}${c.maxDrawdownPct !== null ? ` (${num(c.maxDrawdownPct, 1)}%)` : ''}`);
+                const step = Math.max(1, Math.ceil(c.points.length / 40));
+                for (const [i, p] of c.points.entries())
+                    if (i % step === 0 || i === c.points.length - 1)
+                        out(`  ${when(p.t)}  ${pad(p.symbol, 8)} ${lpad(num(p.pnl, 3), 9)}  cum ${lpad(num(p.cum, 3), 9)}  dd ${lpad(num(p.drawdown, 3), 8)}`);
+                return 0;
+            }
+            case 'compare': {
+                const c = compareStrategies(rows);
+                if (json) {
+                    out(JSON.stringify(c));
+                    return 0;
+                }
+                for (const l of banner(v, rows))
+                    out(l);
+                const u = c.unit === 'SOL' ? '◎' : '$';
+                out(`${pad('strategy', 24)} ${pad('modes', 12)} ${lpad('trades', 6)} ${lpad('open', 4)} ${lpad('win', 4)} ${pad(' (95%)', 10)} ${lpad(`P/L ${u}`, 9)} ${lpad('avg', 7)} ${lpad('maxDD', 8)} ${lpad('rugs', 5)} ${lpad('hold', 6)} ${lpad('MFE', 7)} ${lpad('MAE', 7)} ${lpad('model $', 8)}`);
+                for (const r of c.rows)
+                    out(`${pad(r.key, 24)} ${pad(r.modes.join(','), 12)} ${lpad(String(r.trades), 6)} ${lpad(String(r.open), 4)} ${lpad(frac(r.winRate?.value), 4)} ${pad(r.winRate ? ` ${frac(r.winRate.lo)}–${frac(r.winRate.hi)}` : '', 10)} ${lpad(num(r.pnl, 3), 9)} ${lpad(pct(r.avgPnlPct), 7)} ${lpad(num(r.maxDrawdown, 3), 8)} ${lpad(frac(r.rugRate), 5)} ${lpad(r.avgHoldSec === null ? '—' : hold(r.avgHoldSec), 6)} ${lpad(pct(r.avgMfePct), 7)} ${lpad(pct(r.avgMaePct), 7)} ${lpad(num(r.modelCostUsd), 8)}`);
+                return 0;
+            }
+            case 'export': {
+                const fmt = o._[0] ?? (typeof o.format === 'string' ? o.format : undefined);
+                if (!fmt || !EXPORT_FORMATS.includes(fmt)) {
+                    io.stderr.write(`dexterm ledger export: the format is ${EXPORT_FORMATS.join(' | ')}\n`);
+                    return 2;
+                }
+                const text = exportTrades(rows, fmt, { exportedAt: now, ledgerHead: v.file.check.ok ? v.file.check.head : null, unit: summarize(rows).unit, filters: { ...filter } });
+                if (typeof o.out === 'string') {
+                    writeFileSync(o.out, text, { mode: 0o600 });
+                    io.stderr.write(`wrote ${rows.length} trades to ${o.out}\n`);
+                }
+                else
+                    io.stdout.write(text);
+                return 0;
+            }
+            case 'card': {
+                const id = o._[0];
+                const t = id ? v.trades.find((x) => x.tradeId === id) : undefined;
+                if (!t) {
+                    io.stderr.write(`dexterm ledger card: ${id ? `no trade ${id}` : 'pass a tradeId (from `dexterm ledger trades`)'}\n`);
+                    return 2;
+                }
+                const card = await import("./pnl-card.js");
+                const solUsd = typeof o['sol-usd'] === 'string' ? Number(o['sol-usd']) : null;
+                if (solUsd !== null && !(solUsd > 0)) {
+                    io.stderr.write('dexterm ledger card: --sol-usd is a positive number\n');
+                    return 2;
+                }
+                const input = card.ledgerCardInput(t, { solUsd: solUsd ? { usd: solUsd, source: '--sol-usd' } : null });
+                const s = card.computeCard(input, now);
+                const opts = { aspect: o.square === true ? 'square' : 'wide', exactSize: o.exact === true, ...(o.price === true ? { basis: 'price' } : {}) };
+                const files = card.saveCard(s, opts, { env: io.env, now });
+                out(card.cardText(s, opts));
+                out(`saved ${files.wide}\n      ${files.square}\n      ${files.txt}`);
+                return 0;
+            }
+            default:
+                io.stderr.write(`dexterm ledger: unknown subcommand ${JSON.stringify(sub)}\n\n${LEDGER_HELP}\n`);
+                return 2;
+        }
+    }
+    catch (e) {
+        io.stderr.write(`dexterm ledger: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+}

package/dist/packages/cli/src/live/chart-fills.js

@@ -0,0 +1,46 @@
+const abs = (n) => (n < 0n ? -n : n);
+const fin = (n) => typeof n === 'number' && Number.isFinite(n) && n > 0;
+/** A paper ledger row → a chart fill (its own USD price when the paper engine recorded one). */
+export function paperChartFill(r) {
+    return {
+        t: r.t, side: r.side, source: 'paper',
+        priceUsd: fin(r.priceUsd) ? r.priceUsd : null,
+        tokens: Number(abs(r.tokenDelta)) / 10 ** r.decimals,
+        sol: Number(abs(r.grossLamports)) / 1e9,
+    };
+}
+/** How many paper rows are scanned for one mint (the wallet has no per-mint read; older history drops off first). */
+export const CHART_FILLS_PAPER_SCAN = 2000;
+/** How long one mint's fills are reused (the render loop asks every frame; the popup up to ~20×/s). */
+export const CHART_FILLS_MEMO_MS = 1000;
+/** Every paper fill for one mint, oldest first. A ledger that cannot be read contributes nothing. */
+export function chartFillsFor(mint, rd) {
+    const out = [];
+    try {
+        for (const r of rd.paper?.(CHART_FILLS_PAPER_SCAN) ?? [])
+            if (r.mint === mint)
+                out.push(paperChartFill(r));
+    }
+    catch { /* unreadable paper ledger: no paper marks */ }
+    return out.sort((a, b) => a.t - b.t);
+}
+/** chartFillsFor memoised per mint for CHART_FILLS_MEMO_MS (a fill shows on the chart within a second). */
+export class ChartFills {
+    memo = new Map();
+    rd;
+    now;
+    constructor(rd, now = Date.now) { this.rd = rd; this.now = now; }
+    for(mint) {
+        const now = this.now();
+        const m = this.memo.get(mint);
+        if (m && now - m.at >= 0 && now - m.at < CHART_FILLS_MEMO_MS)
+            return m.v;
+        const v = chartFillsFor(mint, this.rd);
+        if (this.memo.size > 32)
+            this.memo.clear();
+        this.memo.set(mint, { at: now, v });
+        return v;
+    }
+    /** Forget every memo (after a fill this run booked). */
+    invalidate() { this.memo.clear(); }
+}

package/dist/packages/cli/src/live/dev-history.js

@@ -1,4 +1,4 @@
-import { creatorOf, devHistoryLine, queryDevHistory } from '../../../recorder/src/index.js';
+import { ageShort, creatorOf, devHistoryLine, queryDevHistory } from '../../../recorder/src/index.js';
 export const DEV_TTL_MS = 60_000;
 /** Short creator/funder address for the panel (never a full address in a 40-column cell). */
 export const shortAddr = (a) => (a ? `${a.slice(0, 4)}…${a.slice(-4)}` : '—');
@@ -14,9 +14,10 @@ export class DevHistoryBook {
     }
     /**
      * The entry for `mint` (cached for `ttlMs`). `creatorHint` is the dev wallet a source named on screen (Jupiter
-     * `dev`) for a coin the recorder has not linked yet; `intel` is the coin's settled wallet-intel scan, if any.
+     * `dev`) for a coin the recorder has not linked yet; `intel` is the coin's settled wallet-intel scan, if any, and
+     * `intelAt` when that scan settled (the linked row's age).
      */
-    forMint(mint, creatorHint, intel) {
+    forMint(mint, creatorHint, intel, intelAt) {
         const now = this.now();
         const hit = this.cache.get(mint);
         if (hit && now - hit.at < this.ttlMs && (hit.creator || !creatorHint) && (hit.linked || !intel))
@@ -36,7 +37,7 @@ export class DevHistoryBook {
             }
         }
         if (creator && intel)
-            linked = linkedFrom(intel, creator.creator, db);
+            linked = linkedFrom(intel, creator.creator, db, intelAt ?? null);
         const line = !db ? 'unknown: the history recorder is off (--no-recorder / DEXTERM_RECORDER=0)'
             : !creator ? 'unknown: no source named the creator yet'
                 : report ? devHistoryLine(report) : 'unknown: dev history unreadable';
@@ -53,11 +54,11 @@ export class DevHistoryBook {
     }
 }
 /** Linked wallets from a settled wallet-intel scan: the creator's funder and any multi-wallet cluster it sits in. */
-export function linkedFrom(a, creator, db) {
+export function linkedFrom(a, creator, db, at = null) {
     const h = a.holders.find((x) => x.owner === creator);
     const fundedBy = h?.funder?.address ?? a.funding[creator]?.funder ?? null;
     const c = a.clusters.find((x) => x.members.includes(creator) && x.members.length > 1) ?? null;
-    let linkedCreators = 0, linkedRugs = 0;
+    let linkedCreators = 0, linkedRugs = 0, linkedNewestT = null;
     if (c && db) {
         try {
             const others = c.members.filter((m) => m !== creator).slice(0, 50);
@@ -66,25 +67,40 @@ export function linkedFrom(a, creator, db) {
                 if (Number(launched.get(w).n) <= 0)
                     continue;
                 linkedCreators++;
-                linkedRugs += queryDevHistory(db, { creator: w, devExit: false }).labelled.rug;
+                const r = queryDevHistory(db, { creator: w, devExit: false });
+                linkedRugs += r.labelled.rug;
+                if (r.labelled.newestT !== null)
+                    linkedNewestT = Math.max(linkedNewestT ?? 0, r.labelled.newestT);
             }
         }
         catch { /* an old DB without the table: nothing linked */ }
     }
-    return { fundedBy, cluster: c ? { name: c.name, kind: c.kind, members: c.members.length, pct: c.pct } : null, linkedCreators, linkedRugs, source: h || c || a.funding[creator] ? 'wallet-intel scan' : null };
+    return { fundedBy, cluster: c ? { name: c.name, kind: c.kind, members: c.members.length, pct: c.pct } : null, linkedCreators, linkedRugs, linkedNewestT, source: h || c || a.funding[creator] ? 'wallet-intel scan' : null, at };
 }
-/** Rows for the token screen's DEV block: [label, value, level]. Every value names its source/sample/age or says unknown. */
-export function devRows(e) {
+/** Short source tags for a panel cell: `rec` = dexterm's recorder, `scan` = the wallet-intel scan; creator links by feed. */
+const LINK_TAG = { 'jupiter-tokens': 'jup', pumpportal: 'pump', rugcheck: 'rc' };
+const linkTag = (src) => (src ? LINK_TAG[src] ?? src : '?');
+const ageAt = (t, now) => ageShort(t === null || t === undefined ? null : Math.max(0, Math.round((now - t) / 1000)));
+/**
+ * Rows for the token screen's DEV block: [label, value, level]. Every value names its source, sample and age (or
+ * says unknown): `rec` = dexterm's recorder, `scan` = the wallet-intel scan, `dev:jup` = which feed named the creator.
+ * Ages are measured from `now` (default: when the entry was read): the newest label / sighting / exit / scan behind it.
+ */
+export function devRows(e, now = e.at) {
     const rows = [];
     const r = e.report;
     const rugLevel = () => !r || r.labelled.n === 0 ? 'na' : r.serialRugger ? 'bad' : r.labelled.rug > 0 || (r.badRate ?? 0) >= 0.5 ? 'warn' : 'ok';
-    rows.push(['Dev rugs (recorded)', r && r.labelled.n ? `${r.labelled.rug}/${r.labelled.n} · n=${r.labelled.n}` : 'unknown', rugLevel()]);
-    rows.push(['Dev launches seen', r && r.status === 'ok' ? `${r.launches.n} prior · ${e.creator?.source === 'jupiter-tokens' ? 'jup' : e.creator?.source ?? ''}` : 'unknown', 'na']);
+    rows.push(['Dev rugs', r && r.labelled.n ? `${r.labelled.rug}/${r.labelled.n} · n=${r.labelled.n} · rec ${ageAt(r.labelled.newestT, now)}` : 'unknown', rugLevel()]);
+    rows.push(['Dev launches', r && r.status === 'ok' ? `n=${r.launches.n} · rec ${ageAt(r.launches.newestT, now)} · dev:${linkTag(e.creator?.source)}` : 'unknown', 'na']);
     if (r && r.devExit.n)
-        rows.push(['Dev sold its bag', `median ${Math.round(r.devExit.medianMin)}m · n=${r.devExit.n}`, r.devExit.medianMin <= 60 ? 'warn' : 'ok']);
+        rows.push(['Dev sold bag', `med ${Math.round(r.devExit.medianMin)}m · n=${r.devExit.n} · rec ${ageAt(r.devExit.newestT, now)}`, r.devExit.medianMin <= 60 ? 'warn' : 'ok']);
     const l = e.linked;
-    if (l && (l.fundedBy || l.cluster))
-        rows.push(['Dev linked', l.cluster ? `${l.cluster.kind} ${l.cluster.members}w${l.linkedCreators ? ` · ${l.linkedCreators} devs ${l.linkedRugs} rugs` : ''}` : `funded by ${shortAddr(l.fundedBy)}`, l.linkedRugs > 0 ? 'bad' : 'na']);
+    if (l && (l.fundedBy || l.cluster)) {
+        const scan = `scan ${ageAt(l.at, now)}`;
+        rows.push(['Dev linked', l.cluster ? `${l.cluster.kind} ${l.cluster.members}w · ${scan}` : `funded by ${shortAddr(l.fundedBy)} · ${scan}`, 'na']);
+        if (l.linkedCreators)
+            rows.push(['Linked dev rugs', `${l.linkedRugs} · n=${l.linkedCreators} devs · rec ${ageAt(l.linkedNewestT, now)}`, l.linkedRugs > 0 ? 'bad' : 'na']);
+    }
     return rows;
 }
 /** The app's one book (created on first use), reading the live recorder's DB. Null when there is no recorder. */