dexterm-cli 0.1.6 → 0.2.0

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

@@ -4,8 +4,9 @@
 // (observe snapshots + feed membership, the 1 h/2 h/6 h/24 h/72 h outcome sweeps, labels, retention) with no
 // TUI, to be driven by a user-level launchd LaunchAgent on the Mac mini.
 //
-//   dexterm record [run] [--interval S] [--ticks N | --once] [--maintain S] [--max-db-mb N] [--no-newpairs] [--db PATH] [--verbose]
-//   dexterm record install   [--interval S] [--max-db-mb N] [--load] [--dry-run]
+//   dexterm record [run] [--interval S] [--ticks N | --once] [--maintain S] [--max-db-mb N] [--retention-mb N] [--retention-days D]
+//                        [--focus-ticks] [--no-newpairs] [--db PATH] [--verbose]
+//   dexterm record install   [--interval S] [--max-db-mb N] [--retention-mb N] [--retention-days D] [--focus-ticks] [--load] [--dry-run]
 //   dexterm record uninstall [--unload]
 //   dexterm record status    [--db PATH]
 //
@@ -15,13 +16,18 @@
 // the data layer; only the provider name is ever logged). Modest CPU: one feed refresh per `--interval` (60 s
 // default) and recorder maintenance at most every `--maintain` seconds. A soft disk cap pauses OBSERVATION
 // (the growth source) above `--max-db-mb` while labels + retention keep running, so the DB cannot run away.
+// task-1504 (AUTOTRADE-SPEC §3, §10 Q4), both opt-in so an installed collector behaves as before until it is
+// re-installed with them: `--retention-mb N` replaces that pause with eviction of the oldest history (observation
+// never pauses), `--retention-days D` is the age rule for snapshot rows, and `--focus-ticks` runs the autotrade
+// tick lane (5–10 s DexScreener samples of watchlist / held / candidate / open coins, plus 1m candles).
 import { mkdirSync, writeFileSync, existsSync, rmSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { defaultDbPath, resolveRpcUrl, extraRpcUrls, redactSecrets } from '../../data/src/index.js';
 import { PumpPortalClient } from '../../data/src/index.js';
-import { Recorder, recorderEnabled } from '../../recorder/src/index.js';
+import { Recorder, recorderEnabled, dbFocus, focusFilePath, readFocusFile, DEFAULT_TICKS } from '../../recorder/src/index.js';
+import { dextermHome } from "./boot-state.js";
 import { createLiveFeed } from "./feed.js";
 import { NewPairsLive } from "./live/index.js";
 /** The LaunchAgent label (reverse-DNS). One collector per user. */
@@ -41,7 +47,17 @@ export function buildLiveEngine(env, opts) {
         dbPath: opts.dbPath, rpcUrl: rpc.url, rpcFallbackUrl: rpc.fallbackUrl, rpcPublicPool: true, rpcExtraUrls: extraRpcUrls(env),
         onRequest: opts.verbose ? (req, meta, o) => opts.onLog?.(`  ${meta.source.padEnd(14)} ${String(o.status ?? 'ERR').padStart(3)} ${String(o.latencyMs).padStart(5)}ms ${redactSecrets(req.url).slice(0, 110)}\n`) : undefined,
     });
-    const recorder = new Recorder({ path: opts.dbPath, onLog: opts.verbose ? opts.onLog : undefined });
+    // Focus coins for the tick lane: the watchlist + paper positions in this DB, and whatever the autotrade runner /
+    // the app publish in the focus file. Read on every poll (two indexed reads + one small file).
+    const focusFile = focusFilePath(dextermHome(env));
+    const recorder = new Recorder({
+        path: opts.dbPath, onLog: opts.verbose ? opts.onLog : undefined,
+        // The cap reclaims the data layer's expired cache entries (its own rule: a day past their TTL) before it evicts
+        // any history; `feed` is built above, so the hook can reach it.
+        ...(opts.retentionBytes ? { cap: { maxBytes: opts.retentionBytes, reclaim: () => feed.dl.cache.prune() } } : {}),
+        ...(opts.retentionDays ? { retention: { columnsDays: opts.retentionDays } } : {}),
+        ...(opts.focusTicks ? { ticks: { focus: () => [...dbFocus(recorder.database), ...readFocusFile(focusFile, Date.now())] } } : {}),
+    });
     recorder.attach(feed.dl.store);
     let newpairs = null;
     if (!opts.noNewpairs) {
@@ -66,6 +82,8 @@ export function buildLiveEngine(env, opts) {
             recorder.prune();
         }
         catch { /* logged inside; never fatal */ } },
+        enforceCap() { return recorder.enforceCap(); },
+        ...(opts.focusTicks ? { pollTicks: () => recorder.pollTicks(dl) } : {}),
         dbBytes() {
             try {
                 const db = recorder.database;
@@ -101,7 +119,7 @@ export function buildLiveEngine(env, opts) {
  * Never throws out of the loop: an engine error is logged and the loop continues to the next tick.
  */
 export async function runCollectorLoop(engine, opts) {
-    const res = { ticks: 0, observePasses: 0, rowsWritten: 0, maintainPasses: 0, cappedTicks: 0 };
+    const res = { ticks: 0, observePasses: 0, rowsWritten: 0, maintainPasses: 0, cappedTicks: 0, evictions: 0 };
     let lastMaintain = -Infinity;
     for (let i = 0; i < opts.ticks && !opts.aborted(); i++) {
         if (i > 0) {
@@ -111,7 +129,19 @@ export async function runCollectorLoop(engine, opts) {
         }
         res.ticks++;
         let over = false;
-        if (opts.maxDbBytes !== null) {
+        if (opts.capMode === 'evict') {
+            try {
+                const c = engine.enforceCap?.() ?? null;
+                if (c?.evicted)
+                    res.evictions++;
+                if (c?.over)
+                    opts.onLog?.(`record: DB still at ${(c.usedAfter / 1e6).toFixed(0)} MB used after evicting all but the newest hour (other tables are large); observation continues\n`);
+            }
+            catch (e) {
+                opts.onLog?.(`record: retention failed: ${redactSecrets(e.message)}\n`);
+            }
+        }
+        else if (opts.maxDbBytes !== null) {
             const b = engine.dbBytes();
             if (b !== null && b >= opts.maxDbBytes) {
                 engine.prune();
@@ -146,6 +176,29 @@ export async function runCollectorLoop(engine, opts) {
     }
     return res;
 }
+/** task-1504: drive the tick lane every `everyMs` until aborted. Never throws (a failed poll is logged). */
+export async function runTickLoop(engine, opts) {
+    const res = { polls: 0, calls: 0, written: 0 };
+    if (!engine.pollTicks)
+        return res;
+    while (!opts.aborted()) {
+        try {
+            const r = await engine.pollTicks();
+            res.polls++;
+            res.calls += r.calls;
+            res.written += r.written;
+            if (r.error)
+                opts.onLog?.(`record: tick poll failed: ${redactSecrets(r.error)}\n`);
+        }
+        catch (e) {
+            opts.onLog?.(`record: tick poll failed: ${redactSecrets(e.message)}\n`);
+        }
+        if (opts.aborted())
+            break;
+        await opts.sleep(opts.everyMs);
+    }
+    return res;
+}
 const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 /**
  * A user-level LaunchAgent (no sudo). KeepAlive so a crash or a reboot-after-login brings it back, RunAtLoad,
@@ -155,7 +208,7 @@ const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g,
  * collector to run; a true pre-login daemon would be a LaunchDaemon under sudo, which this task does not use.
  */
 export function renderCollectorPlist(o) {
-    const args = [o.nodePath, o.binPath, 'record', 'run', '--interval', String(Math.round(o.intervalMs / 1000)), '--max-db-mb', String(o.maxDbMb)];
+    const args = [o.nodePath, o.binPath, 'record', 'run', '--interval', String(Math.round(o.intervalMs / 1000)), '--max-db-mb', String(o.maxDbMb), ...(o.extraArgs ?? [])];
     const argXml = args.map((a) => `    <string>${esc(a)}</string>`).join('\n');
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -202,10 +255,37 @@ function dataDir(env, db) {
 function sourceBin() {
     return fileURLToPath(new URL('../bin/dexterm.mjs', import.meta.url));
 }
+/** task-1504: the shared `--retention-mb` / `--retention-days` / `--focus-ticks` parser (run + install). */
+function parseRetention(t, next, a) {
+    if (t === '--focus-ticks') {
+        a.focusTicks = true;
+        return null;
+    }
+    if (t === '--retention-mb') {
+        const n = Number(next());
+        if (!Number.isFinite(n) || n < 1)
+            return '--retention-mb needs a number ≥ 1';
+        a.retentionBytes = Math.round(n * 1_000_000);
+        return null;
+    }
+    if (t === '--retention-days') {
+        const n = Number(next());
+        if (!Number.isFinite(n) || n < 1)
+            return '--retention-days needs a number of days ≥ 1';
+        a.retentionDays = n;
+        return null;
+    }
+    return undefined;
+}
 export function parseRun(argv) {
-    const a = { intervalMs: DEFAULT_INTERVAL_MS, ticks: Infinity, maintainMs: DEFAULT_MAINTAIN_MS, maxDbBytes: DEFAULT_MAX_DB_MB * 1_000_000, noNewpairs: false, db: null, verbose: false };
+    const a = { intervalMs: DEFAULT_INTERVAL_MS, ticks: Infinity, maintainMs: DEFAULT_MAINTAIN_MS, maxDbBytes: DEFAULT_MAX_DB_MB * 1_000_000, noNewpairs: false, db: null, verbose: false, retentionBytes: null, retentionDays: null, focusTicks: false };
     for (let i = 0; i < argv.length; i++) {
         const t = argv[i];
+        const r = parseRetention(t, () => argv[++i], a);
+        if (typeof r === 'string')
+            return { error: r };
+        if (r === null)
+            continue;
         if (t === '--verbose' || t === '-v')
             a.verbose = true;
         else if (t === '--no-newpairs')
@@ -248,15 +328,20 @@ export function parseRun(argv) {
 }
 export const RECORD_USAGE = `dexterm record: keep the history recorder fed with no TUI open (task-1414).
 
-  dexterm record [run] [--interval S] [--ticks N | --once] [--maintain S] [--max-db-mb N] [--no-newpairs] [--db PATH] [--verbose]
-  dexterm record install   [--interval S] [--max-db-mb N] [--load] [--dry-run]
+  dexterm record [run] [--interval S] [--ticks N | --once] [--maintain S] [--max-db-mb N] [--retention-mb N] [--retention-days D]
+                       [--focus-ticks] [--no-newpairs] [--db PATH] [--verbose]
+  dexterm record install   [--interval S] [--max-db-mb N] [--retention-mb N] [--retention-days D] [--focus-ticks] [--load] [--dry-run]
   dexterm record uninstall [--unload]
   dexterm record status    [--db PATH]
 
 run        the collector loop: one keyless feed refresh per --interval (default 60 s) feeds the recorder
            (snapshots + feed membership + new pairs), recorder maintenance (outcome sweeps, labels, retention)
            every --maintain seconds. --max-db-mb is a soft cap (default 1024): above it observation pauses while
-           labels + retention keep running. --no-newpairs drops the PumpPortal stream. Ctrl-C stops cleanly
+           labels + retention keep running. --retention-mb N replaces that pause: the oldest history is evicted
+           to stay under N MB and observation never pauses. --retention-days D drops snapshot rows (sweep rows
+           too) older than D days (default 90). --focus-ticks samples watchlist / held / candidate / open coins
+           every 5-10 s (DexScreener batches of 30, a daily call ceiling) with 1m candles; autotrade backtests
+           read them. --no-newpairs drops the PumpPortal stream. Ctrl-C stops cleanly
            (labels whatever is due). Requests honour the data layer's rate limits, health gate and sweep budgets.
 install    write a user-level launchd LaunchAgent (no sudo) that runs \`record run\`; prints the launchctl
            command. --load also runs launchctl (off by default). --dry-run prints the plist, writes nothing.
@@ -300,47 +385,77 @@ async function run(argv, io, deps) {
         return 2;
     }
     // SIGINT/SIGTERM-aware cancellable sleeper (launchd sends SIGTERM to stop the agent).
+    // Several loops may sleep at once (the collector + the tick lane), so every sleeper is woken on abort.
     const stop = (() => {
         let aborted = false;
-        let wake = () => { };
+        const wakes = new Set();
         return {
             get aborted() { return aborted; },
-            abort() { aborted = true; wake(); },
-            sleep(ms) { return new Promise((r) => { const t = setTimeout(r, ms); t.unref?.(); wake = () => { clearTimeout(t); r(); }; }); },
+            abort() { aborted = true; for (const w of [...wakes])
+                w(); },
+            sleep(ms) {
+                return new Promise((r) => {
+                    const done = () => { clearTimeout(t); wakes.delete(done); r(); };
+                    const t = setTimeout(done, ms);
+                    t.unref?.();
+                    wakes.add(done);
+                });
+            },
         };
     })();
     const log = (s) => io.stderr.write(s);
-    const engine = deps.engine ?? buildLiveEngine(io.env, { dbPath, noNewpairs: parsed.noNewpairs, verbose: parsed.verbose, onLog: log });
+    const engine = deps.engine ?? buildLiveEngine(io.env, { dbPath, noNewpairs: parsed.noNewpairs, verbose: parsed.verbose, onLog: log, retentionBytes: parsed.retentionBytes, retentionDays: parsed.retentionDays, focusTicks: parsed.focusTicks });
     const own = !deps.engine;
     const onSig = () => { io.stderr.write('\ndexterm record: stopping…\n'); stop.abort(); };
     if (own) {
         process.on('SIGINT', onSig);
         process.on('SIGTERM', onSig);
     }
+    // The sleeps are unref'd; without the PumpPortal socket (--no-newpairs) nothing else would keep the event loop
+    // alive between passes and node would exit mid-run (task-1504 smoke). Hold it open until the loops finish.
+    const hold = own ? setInterval(() => { }, 1 << 30) : null;
     if (parsed.verbose || parsed.ticks !== Infinity)
-        io.stderr.write(`dexterm record: db ${dbPath} · interval ${Math.round(parsed.intervalMs / 1000)}s · maintain ${Math.round(parsed.maintainMs / 1000)}s · cap ${parsed.maxDbBytes === null ? 'off' : `${Math.round(parsed.maxDbBytes / 1e6)} MB`} · newpairs ${parsed.noNewpairs ? 'off' : 'on'}\n`);
+        io.stderr.write(`dexterm record: db ${dbPath} · interval ${Math.round(parsed.intervalMs / 1000)}s · maintain ${Math.round(parsed.maintainMs / 1000)}s · cap ${parsed.maxDbBytes === null ? 'off' : `${Math.round(parsed.maxDbBytes / 1e6)} MB`} · newpairs ${parsed.noNewpairs ? 'off' : 'on'}${parsed.retentionBytes !== null ? ` · retention ${Math.round(parsed.retentionBytes / 1e6)} MB (evict, never pause)` : ''}${parsed.retentionDays !== null ? ` · rows ${parsed.retentionDays} d` : ''} · focus ticks ${parsed.focusTicks ? 'on' : 'off'}\n`);
     let result;
+    let tickRes = { polls: 0, calls: 0, written: 0 };
     try {
-        result = await runCollectorLoop(engine, {
+        let mainDone = false;
+        const main = runCollectorLoop(engine, {
             intervalMs: parsed.intervalMs, ticks: parsed.ticks, maintainEveryMs: parsed.maintainMs, maxDbBytes: parsed.maxDbBytes,
+            capMode: parsed.retentionBytes !== null ? 'evict' : 'pause',
             now, sleep: (ms) => stop.sleep(ms), aborted: () => stop.aborted, onLog: log,
-        });
+        }).finally(() => { mainDone = true; if (parsed.ticks !== Infinity)
+            stop.abort(); });
+        const lane = parsed.focusTicks && engine.pollTicks
+            ? runTickLoop(engine, { everyMs: DEFAULT_TICKS.fastEveryMs, sleep: (ms) => stop.sleep(ms), aborted: () => stop.aborted || mainDone, onLog: log })
+            : Promise.resolve(tickRes);
+        [result, tickRes] = await Promise.all([main, lane]);
     }
     finally {
         if (own) {
             process.removeListener('SIGINT', onSig);
             process.removeListener('SIGTERM', onSig);
         }
+        if (hold)
+            clearInterval(hold);
         engine.close();
     }
     if (parsed.verbose || parsed.ticks !== Infinity)
-        io.stdout.write(`record: ${result.observePasses} observe pass(es), ${result.rowsWritten} snapshot row(s), ${result.maintainPasses} maintenance pass(es)${result.cappedTicks ? `, ${result.cappedTicks} tick(s) paused at the disk cap` : ''}\n`);
+        io.stdout.write(`record: ${result.observePasses} observe pass(es), ${result.rowsWritten} snapshot row(s), ${result.maintainPasses} maintenance pass(es)${result.cappedTicks ? `, ${result.cappedTicks} tick(s) paused at the disk cap` : ''}${result.evictions ? `, ${result.evictions} retention eviction(s)` : ''}${tickRes.polls ? `, ${tickRes.polls} focus-tick poll(s) (${tickRes.calls} call(s), ${tickRes.written} tick row(s))` : ''}\n`);
     return 0;
 }
 function install(argv, io) {
     let intervalMs = DEFAULT_INTERVAL_MS, maxDbMb = DEFAULT_MAX_DB_MB, load = false, dry = false;
+    const ret = { retentionBytes: null, retentionDays: null, focusTicks: false };
     for (let i = 0; i < argv.length; i++) {
         const t = argv[i];
+        const r = parseRetention(t, () => argv[++i], ret);
+        if (typeof r === 'string') {
+            io.stderr.write(`dexterm record: ${r}\n`);
+            return 2;
+        }
+        if (r === null)
+            continue;
         if (t === '--load')
             load = true;
         else if (t === '--dry-run')
@@ -369,7 +484,12 @@ function install(argv, io) {
     const path = plistPath(io.env);
     const logPath = join(dataDir(io.env), 'collector.log');
     const bin = sourceBin();
-    const plist = renderCollectorPlist({ label: COLLECTOR_LABEL, nodePath: process.execPath, binPath: bin, intervalMs, maxDbMb, logPath, workingDir: resolve(dirname(bin), '..', '..', '..') });
+    const extraArgs = [
+        ...(ret.retentionBytes !== null ? ['--retention-mb', String(Math.round(ret.retentionBytes / 1e6))] : []),
+        ...(ret.retentionDays !== null ? ['--retention-days', String(ret.retentionDays)] : []),
+        ...(ret.focusTicks ? ['--focus-ticks'] : []),
+    ];
+    const plist = renderCollectorPlist({ label: COLLECTOR_LABEL, nodePath: process.execPath, binPath: bin, intervalMs, maxDbMb, extraArgs, logPath, workingDir: resolve(dirname(bin), '..', '..', '..') });
     if (dry) {
         io.stdout.write(plist);
         io.stderr.write(`\ndexterm record: dry run — would write ${path}\n`);
@@ -427,6 +547,7 @@ function status(argv, io) {
             `snapshots       ${s.snapshots} (live ${s.live}, sweep ${s.sweep}, t0 anchors ${s.t0})`,
             `outcomes        ${s.outcomes}${s.outcomes ? ` (${Object.entries(s.outcomesByLabel).map(([k, v]) => `${k} ${v}`).join(', ')})` : ''}`,
             `sweeps          ${s.sweeps} runs · ${s.sweepCallsToday} DexScreener calls today`,
+            `focus ticks     ${s.ticks} rows · ${s.candles} 1m candles · ${s.tickCallsToday} calls today`,
             `span            ${when(s.oldestT)} → ${when(s.newestT)}`,
         ].join('\n') + '\n');
     }

package/dist/packages/cli/src/screens/agent-hud.js

@@ -11,7 +11,7 @@
 // Pure: (canvas, StoryView, opts) → cells. Every number comes from the story (app-computed); nothing here can act.
 // Reduced motion (calm mode / DEXTERM_REDUCED_MOTION) drops every sweep, flash, glitch and typewriter: the same
 // information appears at once. NO_COLOR keeps meaning in glyphs (▸ active phase, ✓ ! ✗ chips, ▶ cursor).
-import { mix, hash3, KATAKANA, decryptText, fmtCompactUsd } from '../../../tui/src/index.js';
+import { mix, hash3, KATAKANA, decryptText, fmtCompactUsd, markerGlyph, markerLetter } from '../../../tui/src/index.js';
 import { STORY_RAIL, fmtQty, fmtPx } from '../../../agents/src/index.js';
 import { pnlChipVM, renderPnlChip } from "./pnl-chip.js";
 /** Rows the dock takes at the bottom of the terminal. */
@@ -550,7 +550,8 @@ function ticketCard(c, v, arc, o, screenH) {
         ['SIZE', arc.sizeUsd != null ? `$${arc.sizeUsd.toFixed(2)}${v.caps ? `   cap $${v.caps.perTradeUsd.toFixed(2)}/trade · $${v.caps.totalUsd.toFixed(0)} total` : ''}` : 'sizing…', arc.sizeUsd != null ? t.text : t.dim],
         ['GATE', 'YOUR keypress armed the mandate · tier hands-free', t.muted],
         ['', 'no keypress per trade inside it · desk enforces caps', mix(bg, t.dim, 0.85)],
-        ['ENTRY', fill ? `${Math.abs(fill.sol).toFixed(4)} SOL → ${fmtQty(fill.qty)} $${arc.symbol}${fill.priceUsd != null ? ` @ $${fmtPx(fill.priceUsd)}` : ''}` : refused ? '—' : 'awaiting confirm · fresh quote at fill', fill ? t.text : t.dim],
+        // task-1537: the fill reads as the market cap it filled at when the HUD's cap scale knows the supply (like the position card)
+        ['ENTRY', fill ? `${Math.abs(fill.sol).toFixed(4)} SOL → ${fmtQty(fill.qty)} $${arc.symbol}${fill.priceUsd != null ? ` @ ${((sc) => (sc ? `MC ${fmtCompactUsd(fill.priceUsd * sc)}` : `$${fmtPx(fill.priceUsd)}`))(o.mcapScale?.(arc.mint) ?? null)}` : ''}` : refused ? '—' : 'awaiting confirm · fresh quote at fill', fill ? t.text : t.dim],
         ['IMPACT', fill?.impactPct != null ? `${fill.impactPct.toFixed(2)}%${v.caps?.maxPriceImpactPct != null ? `   max ${v.caps.maxPriceImpactPct}%` : ''}` : '—', t.muted],
         ['EXITS', 'agent-managed · no resting orders on PAPER', t.muted],
     ];
@@ -585,6 +586,26 @@ function ticketCard(c, v, arc, o, screenH) {
         c.text(x + Math.floor((w - s.length) / 2), sy, s, { fg: mix(bg, t.meteora, pulse), bg });
     }
 }
+/**
+ * task-1483: where the arc's fills sit on the PnL trace: the column of the first sample at or after the fill (the sample
+ * that first reflects it). A fill before the first SHOWN sample when older samples were cut off, or after the last
+ * sample, gets no column (it is not moved onto another one). Columns are 0-based into `shownT`.
+ */
+export function traceFillCols(allT, shownFrom, fills) {
+    const by = new Map();
+    for (const f of fills) {
+        const i = allT.findIndex((t) => t >= f.t);
+        if (i < 0 || i < shownFrom)
+            continue;
+        const key = `${i}|${f.side}`;
+        const e = by.get(key);
+        if (e)
+            e.count++;
+        else
+            by.set(key, { col: i - shownFrom, side: f.side, count: 1 });
+    }
+    return [...by.values()].sort((a, b) => a.col - b.col);
+}
 function positionCard(c, v, arc, o, screenH) {
     const t = c.theme;
     const w = Math.min(62, c.w - 4);
@@ -619,6 +640,17 @@ function positionCard(c, v, arc, o, screenH) {
             const lv = Math.round(((s.pct - lo) / span) * 7);
             c.put(x + 2 + i, y + 6, LV[lv], { fg: s.pct >= 0 ? t.up : t.down, bg, soft: true });
         });
+        // task-1483: the agent's PAPER fills under the trace (△B / ▽S, hollow = paper), at the sample that first shows them
+        const used = new Set();
+        for (const m of traceFillCols(arc.trace.map((s) => s.t), arc.trace.length - tr.length, arc.fills)) {
+            const cx = x + 2 + m.col;
+            if (used.has(m.col) || used.has(m.col + 1) || cx + 1 >= x + w - 1)
+                continue;
+            used.add(m.col);
+            used.add(m.col + 1);
+            const col = m.side === 'buy' ? t.up : t.down;
+            c.text(cx, y + 7, `${markerGlyph(m.side, 'paper')}${markerLetter(m.side)}`, { fg: col, bg: mix(bg, col, 0.2), b: true, hard: true });
+        }
     }
     else
         c.text(x + 2, y + 6, '· waiting for the first mark tick', { fg: t.dim, bg });

package/dist/packages/cli/src/screens/analyst-session.js

@@ -20,7 +20,7 @@ export function renderAnalystSession(c, x, y, w, h, s, opts) {
     // Narrow panels (token screen) drop the model so cost · latency · tools still fits beside the title.
     const full = s.status === 'error' ? 'analyst unavailable' : s.footer;
     // 0.1.5: a codex conversation says so in the title; claude panels keep the original default.
-    const title = opts.title ?? (s.engine === 'codex' ? '✦ ANALYST · codex' : '✦ ANALYST · claude');
+    const title = opts.title ?? (s.engine === 'codex' ? '✦ ANALYST · codex' : s.engine === 'ollama' ? '✦ ANALYST · ollama' : '✦ ANALYST · claude');
     const caption = title.length + full.length + 10 <= w ? full : full.split(' · ').slice(0, 3).join(' · ');
     const capFg = s.status === 'error' ? t.warn : t.dim;
     const box = c.box(x, y, w, h, { title, titleFg: t.ai, caption, captionFg: capFg, border: bc });
@@ -183,7 +183,7 @@ export function renderAnalystSession(c, x, y, w, h, s, opts) {
     // mcap/age + the analyst's one-line reason), navigable with ↑↓ and ⏎-to-jump. The numbers come from
     // live data (resolved by the caller from the app's data layer, never from the model's text).
     if (opts.results?.length && cy < inputY - 1) {
-        cy = renderResultsTable(c, box, bg, cy, inputY, inner, opts.results, opts.resultsCursor ?? 0, opts.resultsActive ?? false);
+        cy = renderResultsTable(c, box, bg, cy, inputY, inner, opts.results, opts.resultsCursor ?? 0, opts.resultsActive ?? false, opts.priceMode !== 'price');
     }
     if (s.candidates.length && cy < inputY - 1) {
         cy += 1;
@@ -251,14 +251,17 @@ function fmtAge(min) {
  * so it stays legible instead of wrapping into prose. The highlighted row (cursor) is tinted; when the
  * table is active a `▸` marks it and the footer hint changes. Returns the new y.
  */
-function renderResultsTable(c, box, bg, startY, inputY, inner, rows, cursor, active) {
+function renderResultsTable(c, box, bg, startY, inputY, inner, rows, cursor, active, mcapFirst = true) {
     const t = c.theme;
     let cy = startY + 1;
     if (cy >= inputY - 1)
         return cy;
     // Column plan: [symbol, price, 24h, liq, vol, mcap, age] then the reason fills the rest. Drop from
     // the right as width shrinks so a narrow panel still shows symbol + price + change + a reason.
-    const full = [['SYMBOL', 10], ['PRICE', 9], ['24H', 8], ['LIQ', 8], ['VOL', 8], ['MCAP', 8], ['AGE', 5]];
+    // task-1537: in the market-cap basis MCAP takes PRICE's slot (the headline number) and PRICE moves to MCAP's
+    const full = mcapFirst
+        ? [['SYMBOL', 10], ['MCAP', 9], ['24H', 8], ['LIQ', 8], ['VOL', 8], ['PRICE', 8], ['AGE', 5]]
+        : [['SYMBOL', 10], ['PRICE', 9], ['24H', 8], ['LIQ', 8], ['VOL', 8], ['MCAP', 8], ['AGE', 5]];
     let cols = full.slice();
     // keep trimming trailing columns until the header + a minimal reason (12) fits
     while (cols.length > 3 && cols.reduce((a, [, w]) => a + w + 1, 0) + 12 > inner - 2)

package/dist/packages/cli/src/screens/analyst.js

@@ -6,6 +6,7 @@ import { Canvas, sparkline, heatPct, decryptText, spinnerGlyph, fmtUsd, fmtPrice
 import { headerModel } from "../state.js";
 import { screenerView } from "../screener/view.js";
 import { renderAnalystSession } from "./analyst-session.js";
+import { priceModeOf } from "../display.js";
 import { resolveAnalystResults } from "../analyst/results.js";
 export function renderAnalyst(c, state) {
     const t = c.theme;
@@ -28,7 +29,7 @@ export function renderAnalyst(c, state) {
             frame: state.vfx.frame, code: state.vfx.code, calm: isCalm(state.vfx),
             input: state.aiInput ?? '', inputFocused: focused,
             scroll: state.aiScroll, revealAll: state.aiRevealAll,
-            results, resultsCursor: state.analyst.resultsCursor, resultsActive,
+            results, resultsCursor: state.analyst.resultsCursor, resultsActive, priceMode: priceModeOf(state), // task-1537
             inputHint: focused ? 'type your question…  ⏎ send · esc blur · analysis not advice'
                 : results.length ? 'i ask · ↑↓ pick coin · ⏎ open · o ticket · esc back'
                     : 'i ask · ⏎ focus · ↑↓ pick coin · PgUp/Dn scroll',
@@ -43,7 +44,7 @@ export function renderAnalyst(c, state) {
     if (state.screener.source !== 'fixtures') {
         const live = state.aiFocused === true;
         const eng = state.analystEngine ?? 'claude'; // 0.1.5: the user's own CLI that will answer (claude | codex)
-        const b = c.box(0, top, chatW, bottom - top, { title: `✦ ANALYST · ${eng}`, titleFg: t.ai, caption: `read-only · local ${eng} CLI · on demand`, captionFg: t.dim, border: bc });
+        const b = c.box(0, top, chatW, bottom - top, { title: `✦ ANALYST · ${eng}`, titleFg: t.ai, caption: `read-only · local ${eng === 'ollama' ? 'ollama model' : `${eng} CLI`} · on demand`, captionFg: t.dim, border: bc });
         const bbg = b.bg;
         const bin = b.w - 2;
         let by = b.y + 1;

package/dist/packages/cli/src/screens/autotrade-journey.js

@@ -0,0 +1,134 @@
+// dexterm — the AUTOTRADE screen's JOURNEY view (`Q`, then `J` on a strategy; 0.2.0 card C). One strategy's ladder:
+// draft → backtested → forward-tested → always-on (paper) → real, with the last backtest (held-out split), the forward
+// test (running or its result next to the backtest), the always-on service membership and the mode.
+//
+// Keys on the view: `b` backtests (recorded as evidence), `F` starts a 24 h forward test (paper, live data, the
+// strategy's own bankroll, in the background), `X` stops it, `A` opens the pending ALWAYS-ON promotion's card (y
+// applies it: autotrade.json gets the paper member). A promotion to REAL is never applied here: it needs the user's own
+// caps and the typed phrase on a terminal (`dexterm autotrade promote apply <pp-id>`). Nothing here reaches a wallet,
+// a key, a mandate or the signer.
+import { dirname } from 'node:path';
+import { PromotionFiles, applyAlwaysOn, createForwardTest, findForwardTest, forwardReport, journeyView, liveState, loadArmings, requestForwardStop, saveForwardTest, windowText, } from '../../../autotrade/src/index.js';
+import { spawnForwardHost } from "../autotrade-cmd/forward.js";
+export const defaultForwardSpawn = (home, t) => spawnForwardHost(home, t, process.env);
+const homeOf = (ui) => dirname(ui.deps.store.dir);
+export function openJourney(ui, id) {
+    if (!id)
+        return 'no strategy selected';
+    ui.journey = { id, view: null, error: null, forward: null, report: null, pending: [], readAt: 0 };
+    ui.view = 'journey';
+    refreshJourney(ui, true);
+    return ui.journey.error;
+}
+/** Re-read the journey (at most every 2 s unless forced): evidence, forward test, pending promotions. */
+export function refreshJourney(ui, force = false) {
+    const j = ui.journey;
+    if (!j)
+        return;
+    const now = ui.deps.now();
+    if (!force && now - j.readAt < 2000)
+        return;
+    j.readAt = now;
+    const home = homeOf(ui);
+    const got = ui.deps.store.get(j.id);
+    if (!got || !got.ok) {
+        j.view = null;
+        j.error = got ? `${j.id} does not validate` : `no strategy ${j.id}`;
+        return;
+    }
+    try {
+        j.view = journeyView(home, got.strategy, { armedHash: loadArmings(home)[j.id]?.strategyHash ?? null });
+        j.forward = findForwardTest(home, j.id, now);
+        j.report = j.forward ? forwardReport(home, j.forward, now) : null;
+        j.pending = new PromotionFiles(home).list({ status: 'pending', id: j.id });
+        j.error = null;
+    }
+    catch (e) {
+        j.error = `journey unreadable: ${e.message}`;
+    }
+}
+/** `F`: a 24 h forward test of this version, on paper, live data, its own bankroll, started in the background. */
+export function journeyForward(ui) {
+    const j = ui.journey;
+    if (!j)
+        return 'F starts a forward test from the journey view (J)';
+    const got = ui.deps.store.get(j.id);
+    if (!got || !got.ok)
+        return `no valid strategy ${j.id}`;
+    if (got.source !== 'user')
+        return `${j.id} is a preset: copy it first (d)`;
+    const home = homeOf(ui);
+    const c = createForwardTest(home, got.strategy, ui.deps.store.raw(j.id), { hours: 24, by: 'user:tui', now: ui.deps.now() });
+    if (!c.ok)
+        return c.why;
+    const pid = (ui.deps.forwardSpawn ?? defaultForwardSpawn)(home, c.test);
+    if (!pid) {
+        saveForwardTest(home, { ...c.test, state: 'failed', endedAt: ui.deps.now(), endReason: 'could not start the host' });
+        return `could not start it; in a terminal: dexterm autotrade forward start ${j.id}`;
+    }
+    refreshJourney(ui, true);
+    return `forward test ${c.test.forwardId} started · ${windowText(c.test.window)} · paper, live data, own bankroll $${c.test.bankrollUsd} · X stops it`;
+}
+/** `X`: stop the running forward test (it flattens and writes its report; an early stop does not count). */
+export function journeyStopForward(ui) {
+    const j = ui.journey;
+    if (!j)
+        return 'X stops a forward test from the journey view (J)';
+    const t = findForwardTest(homeOf(ui), j.id, ui.deps.now());
+    if (!t)
+        return 'no forward test';
+    const r = requestForwardStop(homeOf(ui), t.forwardId, 'tui', ui.deps.now());
+    refreshJourney(ui, true);
+    return r.ok ? `${r.already ? 'already stopping' : 'stop requested'}: ${t.forwardId} flattens and writes its report (an early stop does not count)` : r.why;
+}
+/** `A`: open the pending always-on promotion's confirm card (y applies). Real is a terminal-only step. */
+export function journeyPromote(ui) {
+    const j = ui.journey;
+    if (!j)
+        return 'A applies a promotion from the journey view (J)';
+    refreshJourney(ui, true);
+    const p = j.pending.find((x) => x.to === 'always-on');
+    if (p) {
+        ui.confirm = { kind: 'promote', proposalId: p.proposalId };
+        return `promotion ${p.proposalId} → always-on (proposed by ${p.actor}): y applies, any key cancels`;
+    }
+    const real = j.pending.find((x) => x.to === 'real');
+    if (real)
+        return `real mode is armed only on your own terminal with your caps and a typed phrase: dexterm autotrade promote apply ${real.proposalId}`;
+    return j.view?.next?.stage === 'always-on' ? `nothing pending: ask the analyst to propose it, or in a terminal: dexterm autotrade promote ${j.id} --to always-on` : 'no promotion pending';
+}
+/** The y / any-key answer on the promotion card. */
+export function confirmPromote(ui, proposalId, yes) {
+    if (!yes)
+        return 'promotion not applied (it stays pending)';
+    const j = ui.journey;
+    const got = j ? ui.deps.store.get(j.id) : null;
+    if (!got || !got.ok)
+        return 'the strategy is not valid any more';
+    const a = applyAlwaysOn(homeOf(ui), proposalId, got.strategy, { by: 'user:tui', now: ui.deps.now() });
+    refreshJourney(ui, true);
+    return a.ok ? `applied: ${got.strategy.id} is an always-on paper member (${a.memberId}); the service runs it from its next start` : `not applied: ${a.why}`;
+}
+export function journeyLines(j, now) {
+    if (j.error || !j.view)
+        return [{ text: j.error ?? 'loading…', tone: 'warn' }];
+    const v = j.view;
+    const out = [
+        { text: `${v.id} v${v.version} · rules ${v.rulesHash.slice(0, 8)} · mode ${v.mode} · stage ${v.stage.toUpperCase()}`, tone: 'text' },
+        { text: '', tone: 'dim' },
+        ...v.rungs.map((r) => ({ text: `${r.ok ? '[x]' : '[ ]'} ${r.stage.padEnd(15)} ${r.detail}`, tone: (r.ok ? 'ok' : 'dim') })),
+        ...v.notes.map((n) => ({ text: `!  ${n}`, tone: 'warn' })),
+        { text: v.next ? `next: ${v.next.stage} — ${v.next.how}` : 'top of the ladder: real (caps, kill switch, receipts: dexterm autotrade signal status)', tone: 'text' },
+        { text: '', tone: 'dim' },
+    ];
+    if (j.forward && j.report) {
+        const st = liveState(j.forward, now);
+        out.push({ text: `forward test ${j.forward.forwardId} · ${st.toUpperCase()} · ${windowText(j.forward.window)}`, tone: st === 'running' || st === 'starting' ? 'warn' : 'text' });
+        for (const l of j.report.lines.slice(1))
+            out.push({ text: l.replace(/^  /, ''), tone: 'text' });
+        out.push({ text: '', tone: 'dim' });
+    }
+    for (const p of j.pending)
+        out.push({ text: `pending promotion ${p.proposalId} → ${p.to} (proposed by ${p.actor})${p.to === 'always-on' ? ' · A to review' : ' · terminal only: dexterm autotrade promote apply'}`, tone: 'warn' });
+    return out;
+}