dexterm-cli 0.1.3 → 0.1.5

package/dist/packages/cli/src/larp-detected.js

@@ -0,0 +1,209 @@
+// Local-only LARP/high-risk follow-up draft pipeline (task-1433). History mode reads the recorder
+// without network access, scores only the point-in-time t0 row, joins only later outcome labels, and
+// writes drafts/cards for human review. Live mode performs one read-only enrichment for one mint.
+// Nothing here has X credentials, opens a composer, schedules work, trades, arms, signs or posts.
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createDataLayer, defaultDbPath } from '../../data/src/index.js';
+import { openHistoryReadOnly, exportRecorded } from '../../recorder/src/index.js';
+import { h1Model, rugFeaturesFromRecord, rugFeaturesFromToken } from '../../packs/src/index.js';
+import { Canvas, THEMES } from '../../tui/src/index.js';
+import { writeExport, fmtAge } from "./export.js";
+export const LARP_DRAFT_MIN_SAMPLE = 50;
+export const LARP_DRAFT_HORIZON = 259_200;
+export const LARP_DRAFT_THRESHOLD = 0.5;
+const isoMinute = (t) => new Date(t).toISOString().replace(/:\d\d\.\d{3}Z$/, 'Z');
+const shortMint = (mint) => `${mint.slice(0, 4)}...${mint.slice(-4)}`;
+const pct = (n, d) => `${d ? ((n / d) * 100).toFixed(1) : '0.0'}%`;
+/** One point-in-time flag per mint: earliest flagged t0 with an observed outcome at this horizon. */
+export function buildFollowUpDataset(records, horizonSec = LARP_DRAFT_HORIZON, threshold = LARP_DRAFT_THRESHOLD) {
+    const model = h1Model();
+    const byMint = new Map();
+    for (const r of records) {
+        const outcome = r.outcomes[`${horizonSec}`];
+        if (!outcome || byMint.has(r.mint))
+            continue;
+        const score = model.score(rugFeaturesFromRecord(r.features));
+        if (score < threshold)
+            continue;
+        byMint.set(r.mint, { mint: r.mint, t0: r.t0, score, model: model.id, outcome });
+    }
+    const flagged = [...byMint.values()];
+    const collapsed = flagged.filter((r) => r.outcome.positive);
+    return { horizonSec, threshold, flagged, collapsed, didNotCollapse: flagged.length - collapsed.length };
+}
+function outcomeText(o) {
+    if (o.label === 'rug')
+        return 'recorder label: liquidity-pull condition';
+    if (o.label === 'dead')
+        return 'recorder label: inactive at follow-up';
+    return `recorder label: ${o.label}`;
+}
+function datasetLine(d) {
+    return `Same-dataset follow-up: ${d.collapsed.length}/${d.flagged.length} met the condition (${pct(d.collapsed.length, d.flagged.length)}); ${d.didNotCollapse}/${d.flagged.length} did not.`;
+}
+function cardCanvas(row, d, now) {
+    const c = new Canvas(92, 25, THEMES.cyberspace);
+    const t = c.theme;
+    c.fill(0, 0, c.w, c.h, ' ', { bg: t.bg });
+    c.fill(0, 0, c.w, 3, ' ', { bg: t.headBg });
+    c.text(3, 1, 'LARP DETECTED · RECORDED FOLLOW-UP', { fg: t.warn, bg: t.headBg, b: true });
+    c.textR(0, 1, c.w - 3, shortMint(row.mint), { fg: t.muted, bg: t.headBg });
+    c.text(4, 5, 'AT THE RECORDED MOMENT', { fg: t.muted, b: true });
+    c.text(4, 7, `HIGH RISK ${Math.round(row.score * 100)}/100`, { fg: t.down, b: true });
+    c.text(4, 9, `${row.model} heuristic · model output · risk flag, not a certificate`, { fg: t.text });
+    c.text(4, 10, `${isoMinute(row.t0)} · local recorder · t0 evidence age ${fmtAge((now - row.t0) / 1000)}`, { fg: t.muted });
+    c.text(4, 13, 'LATER OBSERVED', { fg: t.muted, b: true });
+    c.text(4, 15, outcomeText(row.outcome).toUpperCase(), { fg: t.warn, b: true });
+    c.text(4, 17, `${fmtAge(d.horizonSec)} follow-up · ${row.outcome.tier} · labeler evidence`, { fg: t.text });
+    c.text(4, 20, datasetLine(d), { fg: t.muted }, c.w - 8);
+    c.text(4, 22, 'Sources: local dexterm recorder · DexScreener + Jupiter · draft only', { fg: t.muted }, c.w - 8);
+    c.text(4, 23, 'Not financial advice.', { fg: t.muted });
+    return c;
+}
+function historyDraft(row, d, now) {
+    return [
+        'LARP DETECTED — recorded follow-up',
+        '',
+        `Here is what the data showed: graded HIGH RISK ${Math.round(row.score * 100)}/100 at ${isoMinute(row.t0)} by ${row.model} (heuristic model output); ${outcomeText(row.outcome)} at the ${fmtAge(d.horizonSec)} follow-up.`,
+        '',
+        datasetLine(d),
+        '',
+        `Evidence: local dexterm recorder; DexScreener + Jupiter; t0 data age ${fmtAge((now - row.t0) / 1000)} at export; ${row.outcome.tier}; coin ${shortMint(row.mint)}.`,
+        '',
+        'A risk flag is not a certificate. Draft only; a human decides whether to post. Not financial advice.',
+    ].join('\n') + '\n';
+}
+export function renderHistoryDrafts(d, opts) {
+    const now = opts.now ?? Date.now();
+    const min = opts.minSample ?? LARP_DRAFT_MIN_SAMPLE;
+    if (d.flagged.length < min)
+        return { drafts: [], cards: [] };
+    mkdirSync(opts.outDir, { recursive: true, mode: 0o700 });
+    const rows = [...d.collapsed].sort((a, b) => b.t0 - a.t0).slice(0, opts.limit ?? 3);
+    const drafts = [], cards = [];
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const stem = `${String(i + 1).padStart(2, '0')}-${row.mint.slice(0, 4)}-${row.mint.slice(-4)}`;
+        const draft = join(opts.outDir, `${stem}.md`);
+        writeFileSync(draft, historyDraft(row, d, now), { mode: 0o600 });
+        drafts.push(draft);
+        const view = {
+            kind: 'larp-detected', title: `RECORDED FOLLOW-UP · ${shortMint(row.mint)}`, label: 'replay', canvas: cardCanvas(row, d, now),
+            ages: [
+                { name: 't0 evidence', source: 'local recorder · DexScreener + Jupiter', ageSec: (now - row.t0) / 1000 },
+                { name: 'follow-up', source: `${row.outcome.tier} recorder outcome`, ageSec: d.horizonSec },
+            ],
+            report: historyDraft(row, d, now).trimEnd().split('\n'),
+        };
+        const saved = writeExport(view, { dir: opts.outDir, now: now + i, subject: stem });
+        cards.push(saved.png);
+    }
+    return { drafts, cards };
+}
+function parse(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a.startsWith('--'))
+            continue;
+        const value = argv[i + 1];
+        if (value !== undefined && !value.startsWith('--')) {
+            out[a.slice(2)] = value;
+            i++;
+        }
+        else
+            out[a.slice(2)] = true;
+    }
+    return out;
+}
+export const LARP_DETECTED_HELP = `dexterm larp-detected: local draft/card pipeline; never posts or schedules
+
+  dexterm larp-detected --out DIR [--db PATH] [--horizon SEC] [--limit 3]
+  dexterm larp-detected --live MINT --out DIR
+
+History mode is cron-ready and offline: it reads recorder t0 rows plus later labels, requires at least
+${LARP_DRAFT_MIN_SAMPLE} unique flagged coins, and otherwise writes no drafts. Live mode performs one read-only
+keyless lookup and writes a graded-now card. All output is for human review.`;
+function liveFeatures(row) {
+    return rugFeaturesFromToken({
+        liquidity_usd: row.pair.liquidityUsd, mcap: row.mcap?.value ?? row.pair.mcap, age_sec: row.token.createdAt === null ? null : Math.max(0, (Date.now() - row.token.createdAt) / 1000),
+        top10_pct: row.audit?.top10Pct ?? null, dev_pct: row.audit?.devPct ?? null, organic_score: row.stats?.organicScore ?? null,
+        holder_count: row.stats?.holderCount ?? null, mint_authority: row.audit?.mintAuthority ?? null, freeze_authority: row.audit?.freezeAuthority ?? null,
+    });
+}
+async function liveCard(mint, outDir, dbPath, io) {
+    if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(mint)) {
+        io.stderr.write('dexterm larp-detected: --live needs a Solana mint\n');
+        return 2;
+    }
+    const dl = createDataLayer({ dbPath });
+    try {
+        const result = await dl.store.enrich([mint]);
+        const row = result.rows[0];
+        if (!row) {
+            io.stderr.write('dexterm larp-detected: no current market record found for that mint\n');
+            return 2;
+        }
+        const now = Date.now(), model = h1Model(), score = model.score(liveFeatures(row));
+        const c = new Canvas(92, 20, THEMES.cyberspace), t = c.theme;
+        c.fill(0, 0, c.w, c.h, ' ', { bg: t.bg });
+        c.fill(0, 0, c.w, 3, ' ', { bg: t.headBg });
+        c.text(3, 1, 'LARP CHECK · GRADED NOW', { fg: t.warn, bg: t.headBg, b: true });
+        c.textR(0, 1, c.w - 3, shortMint(mint), { fg: t.muted, bg: t.headBg });
+        c.text(4, 6, `${score >= LARP_DRAFT_THRESHOLD ? 'HIGH RISK' : 'BELOW HIGH-RISK LINE'} ${Math.round(score * 100)}/100`, { fg: score >= LARP_DRAFT_THRESHOLD ? t.down : t.up, b: true });
+        c.text(4, 9, `${model.id} heuristic · model output · risk flag, not a certificate`, { fg: t.text });
+        c.text(4, 11, `${isoMinute(now)} · LIVE DATA · DexScreener + Jupiter`, { fg: t.muted });
+        c.text(4, 14, 'No later outcome yet. No person, project or wallet is identified.', { fg: t.text });
+        c.text(4, 17, 'Draft only · human review · not financial advice', { fg: t.muted });
+        const view = { kind: 'larp-now', title: `GRADED NOW · ${shortMint(mint)}`, label: 'live', canvas: c,
+            ages: [{ name: 'market', source: 'DexScreener + Jupiter', ageSec: Math.max(0, (now - Math.max(row.token.fetchedAt, row.pair.fetchedAt)) / 1000) }],
+            report: [`coin ${shortMint(mint)}`, `graded now ${Math.round(score * 100)}/100 · ${model.id} heuristic model output`, 'No later outcome yet. Risk flag, not a certificate. Draft only.'],
+        };
+        const saved = writeExport(view, { dir: outDir, now, subject: `${mint.slice(0, 4)}-${mint.slice(-4)}` });
+        io.stdout.write(`graded-now card: ${saved.png}\n`);
+        return 0;
+    }
+    finally {
+        dl.close();
+    }
+}
+export async function larpDetectedCommand(argv, io) {
+    const o = parse(argv);
+    if (o.help || o.h) {
+        io.stdout.write(LARP_DETECTED_HELP + '\n');
+        return 0;
+    }
+    const dbPath = typeof o.db === 'string' ? resolve(o.db) : (io.env.DEXTERM_DB_PATH || defaultDbPath(io.env));
+    const outDir = typeof o.out === 'string' ? resolve(o.out) : resolve('marketing', 'larp-detected', new Date().toISOString().slice(0, 10));
+    if (typeof o.live === 'string')
+        return liveCard(o.live, outDir, dbPath, io);
+    if (!existsSync(dbPath)) {
+        io.stderr.write(`dexterm larp-detected: no recorder history at ${dbPath}\n`);
+        return 2;
+    }
+    const horizon = typeof o.horizon === 'string' ? Number(o.horizon) : LARP_DRAFT_HORIZON;
+    if (!Number.isFinite(horizon) || horizon <= 0) {
+        io.stderr.write('dexterm larp-detected: --horizon must be positive seconds\n');
+        return 2;
+    }
+    const db = openHistoryReadOnly(dbPath);
+    if (!db) {
+        io.stderr.write('dexterm larp-detected: recorder database could not be opened read-only\n');
+        return 2;
+    }
+    try {
+        const dataset = buildFollowUpDataset(exportRecorded(db, { labelledOnly: true }).records, horizon);
+        if (dataset.flagged.length < LARP_DRAFT_MIN_SAMPLE) {
+            io.stdout.write(`thin sample: ${dataset.flagged.length} unique flagged coins (< ${LARP_DRAFT_MIN_SAMPLE}); wrote no drafts\n`);
+            return 0;
+        }
+        const limit = typeof o.limit === 'string' ? Math.max(0, Math.floor(Number(o.limit))) : 3;
+        const saved = renderHistoryDrafts(dataset, { outDir, limit: Number.isFinite(limit) ? limit : 3 });
+        io.stdout.write(`${datasetLine(dataset)}\nwrote ${saved.drafts.length} draft(s) and ${saved.cards.length} card(s) to ${outDir}\n`);
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}

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

@@ -0,0 +1,99 @@
+import { 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)}` : '—');
+export class DevHistoryBook {
+    cache = new Map();
+    db;
+    now;
+    ttlMs;
+    constructor(db, now = () => Date.now(), ttlMs = DEV_TTL_MS) {
+        this.db = db;
+        this.now = now;
+        this.ttlMs = ttlMs;
+    }
+    /**
+     * 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.
+     */
+    forMint(mint, creatorHint, intel) {
+        const now = this.now();
+        const hit = this.cache.get(mint);
+        if (hit && now - hit.at < this.ttlMs && (hit.creator || !creatorHint) && (hit.linked || !intel))
+            return hit;
+        const db = this.db() ?? null;
+        let creator = db ? creatorOf(db, mint) : null;
+        if (!creator && creatorHint && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(creatorHint))
+            creator = { mint, creator: creatorHint, source: 'jupiter-tokens', firstT: now, createdAt: null };
+        let report = null;
+        let linked = null;
+        if (creator && db) {
+            try {
+                report = queryDevHistory(db, { creator: creator.creator, mint, asOf: now });
+            }
+            catch {
+                report = null;
+            }
+        }
+        if (creator && intel)
+            linked = linkedFrom(intel, creator.creator, db);
+        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';
+        const e = { mint, creator, report, linked, line, at: now };
+        this.cache.set(mint, e);
+        if (this.cache.size > 2000)
+            this.cache.delete(this.cache.keys().next().value);
+        return e;
+    }
+    /** The `devrugs` rule field: labelled prior rugs by this coin's creator; null = unknown (clauses on it are false). */
+    rugsFor(mint) {
+        const e = this.forMint(mint);
+        return e.report && e.report.labelled.n > 0 ? e.report.labelled.rug : null;
+    }
+}
+/** 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) {
+    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;
+    if (c && db) {
+        try {
+            const others = c.members.filter((m) => m !== creator).slice(0, 50);
+            const launched = db.prepare('SELECT COUNT(*) AS n FROM creators WHERE creator = ?');
+            for (const w of others) {
+                if (Number(launched.get(w).n) <= 0)
+                    continue;
+                linkedCreators++;
+                linkedRugs += queryDevHistory(db, { creator: w, devExit: false }).labelled.rug;
+            }
+        }
+        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 };
+}
+/** 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) {
+    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']);
+    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']);
+    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']);
+    return rows;
+}
+/** The app's one book (created on first use), reading the live recorder's DB. Null when there is no recorder. */
+export function devBookOf(state) {
+    if (!state.live?.recorder)
+        return null;
+    if (!state.devBook) {
+        const live = state.live;
+        state.devBook = new DevHistoryBook(() => live?.recorder?.database ?? null);
+    }
+    return state.devBook;
+}

package/dist/packages/cli/src/live/newpairs.js

@@ -20,6 +20,8 @@ export class NewPairsLive {
     dl;
     now;
     onChange;
+    /** 0.1.5 dev history: called once per row when its creator becomes known (the recorder stores the link). */
+    onCreator;
     limit;
     polls;
     rows = new Map();
@@ -84,6 +86,12 @@ export class NewPairsLive {
         this.mode = 'replay';
         return this.client.replay(rec, speed);
     }
+    tellCreator(mint, creator, source, createdAt) {
+        try {
+            this.onCreator?.(mint, creator, source, createdAt);
+        }
+        catch { /* the recorder must never break the feed */ }
+    }
     addCreate(c) {
         const rowAt = this.now();
         const existing = this.rows.get(c.mint);
@@ -105,6 +113,8 @@ export class NewPairsLive {
         }
         else {
             this.rows.set(c.mint, row);
+            if (row.creator)
+                this.tellCreator(c.mint, row.creator, c.creator ? 'pumpportal' : 'rugcheck', row.createdAt);
             this.latencies.push(row.latencyMs);
             if (this.latencies.length > 500)
                 this.latencies.shift();
@@ -227,6 +237,8 @@ export class NewPairsLive {
                 const row = this.rows.get(t.mint);
                 if (!row)
                     continue;
+                if (!row.creator && t.creator)
+                    this.tellCreator(t.mint, t.creator, 'rugcheck', row.createdAt);
                 row.creator = row.creator ?? t.creator;
                 if (t.mintAuthority !== null)
                     row.mintAuth = t.mintAuthority;

package/dist/packages/cli/src/live/screens/token-live.js

@@ -15,6 +15,7 @@ import { drawCoin, imagesOn } from "../../screens/coin.js";
 import { COIN_HERO_W, COIN_HERO_H } from '../../../../tui/src/index.js';
 import { renderSocialPanel } from "../../screens/social-panel.js";
 import { launchIntelCells, holderTags } from "../intel.js";
+import { devBookOf, devRows } from "../dev-history.js";
 import { EX_POOL_TAGS } from '../../../../data/src/index.js';
 import { layoutFor } from "../../custom.js";
 import { chartMode, priceModeOf, mcapAt, positionPriceCells } from "../../display.js";
@@ -178,6 +179,12 @@ export function renderTokenLive(c, state, v) {
         const top10Rows = tags.top10
             ? [['Top 10 ex-pool', `${tags.top10.exPool.toFixed(1)}%`, t10lvl(tags.top10.exPool)], ['Top 10 raw', `${tags.top10.raw.toFixed(1)}%`, 'na']]
             : [['Top 10 holders', ...(v.top10 === null ? na(v.panels.holders.state === 'needs-key' ? 'needs key' : dash) : [`${v.top10.toFixed(1)}%${v.panels.holders.state === 'ok' ? '' : ' (jup)'}`, t10lvl(v.top10)])]];
+        // 0.1.5 dev history (task-1425): the creator's recorded track record from the local recorder (keyless). The rugs
+        // row sits with the other rug signals; launches / bag-exit / linked wallets follow the safety list.
+        const book = devBookOf(state);
+        const devAll = book ? devRows(book.forMint(v.mint, v.devAddress ?? null, state.live?.intel?.analysis(v.mint) ?? null)) : [];
+        const devHead = devAll.slice(0, 1);
+        const devTail = devAll.slice(1);
         const sniperRow = [cells.snipers.text, cells.snipers.level];
         const bundleRow = [cells.bundle.text, cells.bundle.level];
         const rows = [
@@ -189,8 +196,10 @@ export function renderTokenLive(c, state, v) {
             ['Mint authority', ...(v.mintAuth === null ? na(dash) : [v.mintAuth ? 'ENABLED' : 'revoked', v.mintAuth ? 'bad' : 'ok'])],
             ['Freeze authority', ...(v.freezeAuth === null ? na(dash) : [v.freezeAuth ? 'ENABLED' : 'revoked', v.freezeAuth ? 'bad' : 'ok'])],
             ['Dev history', ...(v.devMints === null ? needsHistory : [`${v.devMints} mints by dev (jup)`, v.devMints > 3 ? 'warn' : 'ok'])],
+            ...devHead,
             ['RugCheck score', ...(v.rug === null || v.rug.score === null ? na(v.panels.rugcheck.state === 'error' ? `unavailable: ${v.panels.rugcheck.reason ?? ''}`.trim() : dash) : [`${Math.round(v.rug.score)}/100`, v.rug.score < 30 ? 'ok' : v.rug.score < 60 ? 'warn' : 'bad'])],
             ['GoPlus', ...goplusRow(v)],
+            ...devTail,
         ];
         for (const [label, val0, lvl] of rows) {
             if (sy >= sb.y + sb.h)
@@ -435,7 +444,8 @@ function analystPlaceholder(c, x, y, w, h, v, state) {
     // task-1311 (QA M5): the pre-run state. Opening a token no longer spends a paid dossier; this panel
     // waits until you ask for one with `a` (dossier) or type a question with `i`. No fake verdicts.
     const t = c.theme;
-    const box = c.box(x, y, w, h, { title: '✦ ANALYST · claude', titleFg: t.ai, caption: 'read-only · local claude · on demand', captionFg: t.dim, border: mix(t.border, t.ai, 0.35) });
+    const eng = state.analystEngine ?? 'claude'; // 0.1.5: the user's own CLI that will answer
+    const box = c.box(x, y, w, h, { title: `✦ ANALYST · ${eng}`, titleFg: t.ai, caption: `read-only · local ${eng} · on demand`, captionFg: t.dim, border: mix(t.border, t.ai, 0.35) });
     const bg = box.bg;
     const inner = box.w - 2;
     let cy = box.y;

package/dist/packages/cli/src/live/token.js

@@ -266,6 +266,7 @@ export class TokenLive {
                 v.top10 = audit?.top10Pct ?? v.top10;
             v.dev = audit?.devPct ?? null;
             v.devMints = audit?.devMints ?? null;
+            v.devAddress = audit?.devAddress ?? v.devAddress ?? null;
             v.sources = [...new Set([...v.sources, ...r.sources])];
             const SHORT = { dexscreener: 'ds', 'jupiter-tokens': 'jup', 'jupiter-price': 'jup-price' };
             this.ok('market', r.sources.map((x) => SHORT[x] ?? x).join('+'), pair.fetchedAt, r.stale);
@@ -473,6 +474,9 @@ export class CandlePrefetcher {
     timer = null;
     busy = false;
     closed = false;
+    settledPromise = Promise.resolve();
+    resolveSettled = null;
+    waitingForSettled = false;
     stamps = [];
     /** Requests actually sent (granted by the limiter). */
     requests = 0;
@@ -494,9 +498,25 @@ export class CandlePrefetcher {
             return;
         if (t && this.target && t.mint === this.target.mint && t.pair === this.target.pair)
             return; // same row: keep waiting
+        this.finishSettled(); // a replaced target can no longer do useful work for its caller
         this.target = t;
+        if (t?.pair)
+            this.settledPromise = new Promise((resolve) => { this.resolveSettled = resolve; });
         this.schedule(this.opts.debounceMs);
     }
+    /**
+     * Resolve after the current hover pass has warmed every immediately available base, explicitly
+     * deferred the next attempt, failed a real request, been replaced, or been cancelled by close(). This
+     * is the completion contract for callers that need to observe the pass result; a debounce timer firing
+     * alone does not mean its sequential requests have finished.
+     */
+    settled() {
+        if (this.resolveSettled) {
+            this.waitingForSettled = true;
+            this.timer?.ref?.();
+        }
+        return this.settledPromise;
+    }
     /** Requests sent in the trailing 60 s. */
     rate() {
         const now = this.opts.now();
@@ -511,6 +531,7 @@ export class CandlePrefetcher {
             clearTimeout(this.timer);
             this.timer = null;
         }
+        this.finishSettled();
     }
     schedule(ms) {
         if (this.timer) {
@@ -521,7 +542,10 @@ export class CandlePrefetcher {
         if (!t || !t.pair || this.closed)
             return;
         this.timer = setTimeout(() => { this.timer = null; void this.step(t); }, Math.max(0, ms));
-        this.timer.unref?.();
+        if (this.waitingForSettled)
+            this.timer.ref?.();
+        else
+            this.timer.unref?.();
     }
     bases() {
         const iv = this.opts.interval();
@@ -541,6 +565,7 @@ export class CandlePrefetcher {
                 continue;
             if (this.rate() >= this.opts.maxPerMin) {
                 this.schedule(this.stamps[0] + 60_000 - this.opts.now() + 50);
+                this.finishSettled(t);
                 return;
             }
             this.busy = true;
@@ -554,9 +579,11 @@ export class CandlePrefetcher {
                     // Try again when the bucket could be idle again (still only if the cursor stays here).
                     const wait = this.dl.limiter.bucket('geckoterminal').delayFor('idle', this.opts.now());
                     this.schedule(Number.isFinite(wait) ? Math.max(250, wait) : 60_000);
+                    this.finishSettled(t);
                     return;
                 }
                 this.sent(); // a real request that failed (HTTP error) still counts against the budget
+                this.finishSettled(t);
                 return;
             }
             finally {
@@ -565,6 +592,17 @@ export class CandlePrefetcher {
             if (this.closed || this.target !== t)
                 return; // the cursor moved on: its own debounce takes over
         }
+        this.finishSettled(t);
+    }
+    finishSettled(t) {
+        if (t && this.target !== t)
+            return;
+        const resolve = this.resolveSettled;
+        this.resolveSettled = null;
+        if (this.waitingForSettled)
+            this.timer?.unref?.();
+        this.waitingForSettled = false;
+        resolve?.();
     }
     sent() {
         this.requests++;