dexterm-cli 0.1.6 → 0.1.7

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-keys.js

@@ -0,0 +1,169 @@
+// dexterm — the AUTOTRADE screen's key handling (`Q`, task-1508). The loop calls autotradeKey() first while the
+// screen captures typed keys (an id / file line, a field value, the flatten confirm), and autotradeAction() for
+// every resolved action while the screen is open. Both only change this screen's state and the user's own
+// strategy files; nothing here reaches a wallet, a key, a mandate or the signer.
+import { INPUT_MAX, backtestSubject, beginFieldEdit, beginImport, beginNew, commitInput, commitTyping, confirmKey, exportSelected, nextView, openEditor, reloadList, refreshRunner, revalidateTyping, runnerVerb, saveEditor, selectedEntry, startBacktest, startCompareBacktest, startSweep, toggleMark, undoEditor, } from "./autotrade-ui.js";
+import { openReview, reviewKey } from "./autotrade-proposals.js";
+const PRINTABLE = (k) => (k.name === 'space' ? ' ' : k.name === 'char' && k.ch && !k.ctrl && !k.alt && !/[\u0000-\u001f\u007f]/.test(k.ch) ? k.ch : null);
+/** A captured key (input line, field value or confirm). Returns true when the key was consumed. */
+export function autotradeKey(ui, key) {
+    // task-1507: a chat proposal's review card owns the keyboard (y applies, a LOOSER edit needs a second y, n dismisses)
+    if (ui.review) {
+        ui.notice = reviewKey(ui, key);
+        if (!ui.review)
+            reloadList(ui);
+        return true;
+    }
+    if (ui.confirm) {
+        ui.notice = confirmKey(ui, key.name === 'char' && key.ch === 'y' && !key.ctrl && !key.alt);
+        return true;
+    }
+    if (ui.input) {
+        const inp = ui.input;
+        if (key.name === 'esc') {
+            ui.input = null;
+            ui.notice = null;
+            return true;
+        }
+        if (key.name === 'enter') {
+            ui.notice = commitInput(ui);
+            return true;
+        }
+        if (key.name === 'backspace') {
+            inp.text = inp.text.slice(0, -1);
+            return true;
+        }
+        if (key.ctrl && key.ch === 'u') {
+            inp.text = '';
+            return true;
+        }
+        const ch = PRINTABLE(key);
+        // an id is lowercase letters, digits and dashes only, so it can never carry a path
+        if (ch && (inp.kind === 'import' ? inp.text.length < INPUT_MAX : /^[a-z0-9-]$/.test(ch) && inp.text.length < 32))
+            inp.text += ch;
+        return true;
+    }
+    const ty = ui.view === 'editor' ? ui.editor?.typing : null;
+    if (ty) {
+        if (key.name === 'esc') {
+            ui.editor.typing = null;
+            ui.notice = null;
+            return true;
+        }
+        if (key.name === 'enter') {
+            ui.notice = commitTyping(ui);
+            return true;
+        }
+        if (key.name === 'backspace')
+            ty.text = ty.text.slice(0, -1);
+        else if (key.ctrl && key.ch === 'u')
+            ty.text = '';
+        else {
+            const ch = PRINTABLE(key);
+            if (ch && ty.text.length < INPUT_MAX)
+                ty.text += ch;
+            else
+                return true;
+        }
+        revalidateTyping(ui);
+        return true;
+    }
+    return false;
+}
+function move(ui, delta) {
+    if (ui.view === 'list')
+        ui.selected = Math.max(0, Math.min(ui.entries.length - 1, ui.selected + delta));
+    else if (ui.view === 'editor' && ui.editor)
+        ui.editor.selected = Math.max(0, Math.min(ui.editor.fields.length - 1, ui.editor.selected + delta));
+    else if (ui.view === 'compare' && ui.compare)
+        ui.compare.scroll = Math.max(0, ui.compare.scroll + delta);
+}
+const PAGE = 10;
+/**
+ * One resolved action on the AUTOTRADE screen. Returns true when it was handled here (the loop then does
+ * nothing else with it); false lets the loop's own handling run (esc on the list pops the screen stack, `q`
+ * quits, the global screen keys still navigate away).
+ */
+export function autotradeAction(ui, action) {
+    const say = (s) => { ui.notice = s ?? null; return true; };
+    const e = selectedEntry(ui);
+    switch (action) {
+        case 'move.down':
+            move(ui, 1);
+            return true;
+        case 'move.up':
+            move(ui, -1);
+            return true;
+        case 'move.pagedown':
+            move(ui, PAGE);
+            return true;
+        case 'move.pageup':
+            move(ui, -PAGE);
+            return true;
+        case 'move.top':
+            move(ui, -1e9);
+            return true;
+        case 'move.bottom':
+            move(ui, 1e9);
+            return true;
+        case 'back':
+            if (ui.view === 'list')
+                return false;
+            ui.view = 'list';
+            return say(null);
+        case 'autotrade.view':
+            nextView(ui);
+            if (ui.view === 'runner')
+                refreshRunner(ui);
+            return say(null);
+        case 'open':
+        case 'autotrade.edit':
+            if (ui.view === 'editor')
+                return say(beginFieldEdit(ui));
+            if (ui.view !== 'list')
+                return action === 'open' ? true : say('e edits from the strategies list');
+            return say(e ? openEditor(ui, e.id) : 'no strategy selected');
+        case 'autotrade.new': return say(ui.view === 'list' ? beginNew(ui, false) : 'n works on the strategies list (esc)');
+        case 'autotrade.dup': return say(ui.view === 'list' ? beginNew(ui, true) : 'd works on the strategies list (esc)');
+        case 'autotrade.import':
+            if (ui.view !== 'list')
+                return say('i works on the strategies list (esc)');
+            beginImport(ui);
+            return say(null);
+        case 'autotrade.export': return say(ui.view === 'list' ? exportSelected(ui) : 'x works on the strategies list (esc)');
+        case 'autotrade.compare': return say(ui.view === 'list' ? toggleMark(ui) : 'c marks strategies on the list (esc)');
+        case 'autotrade.save': return say(ui.view === 'editor' ? saveEditor(ui) : 's saves in the editor');
+        case 'autotrade.undo': return say(ui.view === 'editor' ? undoEditor(ui) : 'u undoes in the editor');
+        case 'autotrade.backtest': {
+            if (ui.view === 'compare')
+                return say(startCompareBacktest(ui));
+            if (ui.view === 'editor' && ui.editor)
+                return say(`${startBacktest(ui, ui.editor.id)}${ui.editor.edits.length ? ' (the saved version; s saves your edits first)' : ''}`);
+            if (ui.view === 'backtest') {
+                const s = backtestSubject(ui);
+                return say(s ? startBacktest(ui, s.id) : 'no strategy selected');
+            }
+            return say(e ? startBacktest(ui, e.id) : 'no strategy selected');
+        }
+        case 'autotrade.sweep': {
+            const id = ui.view === 'editor' && ui.editor ? ui.editor.id : ui.view === 'backtest' ? backtestSubject(ui)?.id : e?.id;
+            return say(id ? startSweep(ui, id) : 'no strategy selected');
+        }
+        case 'autotrade.proposal': return say(ui.view === 'list' ? openReview(ui) || null : 'o reviews chat proposals on the strategies list (esc)');
+        case 'autotrade.run':
+            ui.view = 'runner';
+            refreshRunner(ui);
+            reloadList(ui);
+            return say('starting and stopping a paper run ships with the runner (not in this build yet) · this view shows a runner as soon as one writes its status file');
+        case 'autotrade.kill':
+            refreshRunner(ui);
+            return say(runnerVerb(ui, 'kill'));
+        case 'autotrade.pause':
+            refreshRunner(ui);
+            return say(runnerVerb(ui, 'pause'));
+        case 'autotrade.flatten':
+            refreshRunner(ui);
+            return say(runnerVerb(ui, 'flatten'));
+        default: return false;
+    }
+}