dexterm-cli 0.1.6 → 0.1.7

package/dist/packages/popup/src/pages/chart.js

@@ -15,6 +15,8 @@
   const chipEl = $('pnlchip');
   const imgSlot = $('coin-img-slot');
   const chartEl = $('chart'), drawCv = $('draw'), dctx = drawCv.getContext('2d');
+  // task-1483: the BUY / SELL marker hover card (built with textContent only)
+  const tipEl = document.createElement('div'); tipEl.className = 'mtip'; tipEl.hidden = true; chartEl.parentNode.appendChild(tipEl);
   const STALE_MS = 20_000;
   const DEFAULT_IND = ['volume', 'tape', 'ema9', 'ema21'];
   /** Exposed for the headless harness (measure/popup-v2-1325): first paint + setData → repaint latency. */
@@ -26,6 +28,8 @@
     draw: null, tPending: null, hover: null, drawings: [], lastDataAt: 0, firstPainted: false, fitNext: true,
     banners: { fallback: null, data: null },
     display: C.displayOf(null), // task-1366: price | mcap (from the VM's priceMode + supply)
+    marks: null, // task-1483: { set, on } — the BUY / SELL markers for the bars on screen (chart-lib chartMarkers)
+    mouse: null, // task-1483: crosshair point for the marker hover card
   };
 
   const banner = () => {
@@ -88,7 +92,8 @@
   function levels() {
     const vm = S.vm || {}, pos = vm.position || null, out = [];
     const last = S.bars.length ? S.bars[S.bars.length - 1].close : null;
-    for (const v of [pos && pos.avgEntryUsd, pos && pos.stopUsd, pos && pos.targetUsd, vm.feed === 'LIVE' ? vm.livePrice : null]) {
+    const mk = S.marks && S.marks.on ? S.marks.set.markers.map((m) => m.priceUsd) : []; // task-1483: keep the fills in view
+    for (const v of [pos && pos.avgEntryUsd, pos && pos.stopUsd, pos && pos.targetUsd, vm.feed === 'LIVE' ? vm.livePrice : null, ...mk]) {
       if (typeof v === 'number' && v > 0 && last && v / last < 3 && last / v < 3) out.push(v);
     }
     return out;
@@ -160,7 +165,7 @@
   DT.onTheme(applyChartTheme);
 
   // ---------------------------------------------------------------- toolbar (buttons built with textContent only)
-  const btns = { tf: new Map(), axis: new Map(), styles: new Map(), scales: new Map(), inds: new Map(), draws: new Map() };
+  const btns = { tf: new Map(), axis: new Map(), marks: new Map(), styles: new Map(), scales: new Map(), inds: new Map(), draws: new Map() };
   function mkBtn(group, id, label, title, onClick) {
     const b = document.createElement('button'); b.type = 'button'; b.className = 'tb'; b.textContent = label; b.title = title;
     b.addEventListener('click', (e) => { e.preventDefault(); onClick(); });
@@ -170,6 +175,8 @@
   // task-1472: MCAP | PRICE asks the terminal to switch (and save) the chart axis; the next VM re-labels the page
   mkBtn('axis', 'mcap', 'MCAP', 'Y axis: market cap (A / y toggles; saved by the terminal)', () => setAxis('mcap'));
   mkBtn('axis', 'price', 'PRICE', 'Y axis: USD price (A / y toggles; saved by the terminal)', () => setAxis('price'));
+  // task-1483: MARKERS on/off asks the terminal to switch (and save) display.chartMarkers; the next VM carries it
+  mkBtn('marks', 'on', 'MARKERS', 'BUY / SELL markers of your paper + live fills (k toggles; saved by the terminal)', () => setMarkers(!(S.vm && S.vm.marks && S.vm.marks.on)));
   mkBtn('styles', 'candles', 'candles', 'candlesticks (c cycles)', () => setStyle('candles', true));
   mkBtn('styles', 'line', 'line', 'line (c cycles)', () => setStyle('line', true));
   mkBtn('styles', 'area', 'area', 'area (c cycles)', () => setStyle('area', true));
@@ -189,6 +196,8 @@
     for (const [iv, b] of btns.tf) { b.classList.toggle('on', iv === S.interval); b.classList.toggle('pending', iv === S.pendingInterval && iv !== S.interval); }
     const ax = S.vm && S.vm.priceMode === 'mcap' ? 'mcap' : 'price';
     for (const [k, b] of btns.axis) b.classList.toggle('on', k === ax);
+    const mOn = !!(S.vm && S.vm.marks && S.vm.marks.on);
+    for (const [, b] of btns.marks) { b.classList.toggle('on', mOn); b.hidden = !(S.vm && S.vm.marks); }
     for (const [k, b] of btns.styles) b.classList.toggle('on', k === S.style);
     for (const [k, b] of btns.scales) b.classList.toggle('on', k === S.scale);
     for (const [k, b] of btns.inds) b.classList.toggle('on', S.ind.has(k));
@@ -207,6 +216,11 @@
     if (axis !== 'mcap' && axis !== 'price') return;
     DT.send({ type: 'event', name: 'chart.axis', payload: { axis } });
   }
+  /** task-1483: ask the terminal to show / hide the markers; nothing changes here until its next VM says so. */
+  function setMarkers(on) {
+    if (typeof on !== 'boolean') return;
+    DT.send({ type: 'event', name: 'chart.markers', payload: { on } });
+  }
   function setStyle(st, user) {
     if (!C.STYLES.includes(st) || st === S.style) return;
     S.style = st;
@@ -271,9 +285,82 @@
     const times = new Set(S.bars.map((b) => b.time));
     const list = [];
     if (S.ind.has('tape')) list.push(...C.tapeMarkers(vm.trades, periodMs(), times, { up: DT.rgba(T.up, 0.85), down: DT.rgba(T.down, 0.85) }));
-    if (vm.position && vm.position.fills) list.push(...C.fillMarkers(vm.position.fills, periodMs(), times, { buy: T.accent, sell: T.warn }));
     list.sort((a, b) => a.time - b.time);
     markers[S.style].setMarkers(list);
+    computeMarks();
+  }
+
+  // ---------------------------------------------------------------- task-1483: BUY / SELL markers of the ledgers' fills
+  // Bucketed to THIS page's timeframe by the bars' real times (re-bucketed on every timeframe change), drawn on the
+  // overlay canvas so paper (hollow) and live (solid) read apart, re-clustered when zooming out, hover card per marker.
+  function computeMarks() {
+    const mk = S.vm && S.vm.marks;
+    if (!mk) { S.marks = null; return; }
+    S.marks = { on: !!mk.on, truncated: mk.truncated | 0, set: C.chartMarkers(mk.fills, periodMs(), S.bars.map((b) => b.t)) };
+  }
+  const MARK_PX = 6;
+  let markHits = [];
+  function drawMarks(ts, s, paneH) {
+    markHits = [];
+    const mk = S.marks;
+    if (!mk || !mk.on || !S.bars.length) return;
+    const x0 = ts.logicalToCoordinate(0), x1 = ts.logicalToCoordinate(1);
+    const spacing = x0 != null && x1 != null ? Math.abs(x1 - x0) : 7;
+    // closed round trips: a faint wash entry → exit (green when sold above the entry)
+    for (const r of mk.set.trips) {
+      const a = C.logicalOf(S.bars, C.chartTime(Math.floor(r.openT / periodMs()) * periodMs()), periodMs() / 1000);
+      const b = C.logicalOf(S.bars, C.chartTime(Math.floor(r.closeT / periodMs()) * periodMs()), periodMs() / 1000);
+      const xa = ts.logicalToCoordinate(a), xb = ts.logicalToCoordinate(b);
+      if (xa == null || xb == null) continue;
+      const win = r.entryUsd !== null && r.exitUsd !== null ? r.exitUsd >= r.entryUsd : null;
+      dctx.fillStyle = DT.rgba(win === null ? T.muted : win ? T.up : T.down, 0.07);
+      dctx.fillRect(Math.min(xa, xb) - spacing / 2, 0, Math.abs(xb - xa) + spacing, paneH);
+    }
+    const shown = C.clusterMarkers(mk.set.markers, spacing, 14);
+    const used = new Map();
+    dctx.font = 'bold 10px ui-monospace, Menlo, monospace'; dctx.textAlign = 'center'; dctx.textBaseline = 'middle';
+    for (const m of shown) {
+      const x = ts.logicalToCoordinate(m.index);
+      const bar = S.bars[m.index];
+      if (x == null || !bar) continue;
+      const buy = m.side === 'buy';
+      let y = m.priceUsd !== null ? s.priceToCoordinate(m.priceUsd) : s.priceToCoordinate(buy ? bar.low : bar.high);
+      if (y == null) continue;
+      if (m.priceUsd === null) y += buy ? 4 : -4; // no recorded price: against the bar, never at a made-up price
+      // a second marker on the same bar and side steps away from the bar, never across it
+      const k = `${m.index}|${m.side}`; const n = used.get(k) || 0; used.set(k, n + 1);
+      if (n) y += (buy ? 1 : -1) * n * (MARK_PX * 1.6 + 12);
+      if (y < -20 || y > paneH + 20) continue;
+      const g = C.markerShape(m.side, x, y, MARK_PX);
+      const col = buy ? T.up : T.down;
+      dctx.beginPath(); dctx.moveTo(g.tri[0][0], g.tri[0][1]); dctx.lineTo(g.tri[1][0], g.tri[1][1]); dctx.lineTo(g.tri[2][0], g.tri[2][1]); dctx.closePath();
+      // a dark halo first, so a green buy still reads on a green candle (and a red sell on a red one)
+      dctx.setLineDash([]); dctx.lineJoin = 'round'; dctx.lineWidth = 4; dctx.strokeStyle = DT.rgba(T.bg, 0.92); dctx.stroke();
+      if (m.source === 'live') { dctx.fillStyle = col; dctx.fill(); dctx.lineWidth = 1.2; dctx.strokeStyle = DT.rgba(T.text, 0.95); dctx.stroke(); } // solid + a light edge: never mistaken for a hollow paper mark on a same-colour candle
+      else { dctx.fillStyle = DT.rgba(T.bg, 0.85); dctx.fill(); dctx.fillStyle = DT.rgba(col, 0.22); dctx.fill(); dctx.lineWidth = 1.6; dctx.strokeStyle = col; dctx.stroke(); }
+      const txt = `${C.markerLetter(m.side)}${m.count > 1 ? '×' + m.count : ''}`;
+      dctx.lineWidth = 3; dctx.strokeStyle = DT.rgba(T.bg, 0.92); dctx.strokeText(txt, g.labelX, g.labelY);
+      dctx.fillStyle = col; dctx.fillText(txt, g.labelX, g.labelY);
+      markHits.push({ m, hit: g.hit, x, y });
+    }
+    hoverMarks();
+  }
+  /** The hover card for the marker under the crosshair (time, price, size, source). Text only. */
+  function hoverMarks() {
+    const p = S.mouse;
+    const hit = p ? markHits.find((h) => p.x >= h.hit.x0 && p.x <= h.hit.x1 && p.y >= h.hit.y0 && p.y <= h.hit.y1) : null;
+    if (!hit) { if (!tipEl.hidden) tipEl.hidden = true; return; }
+    const lines = C.markerTooltip(hit.m, S.display, (ms) => fmtTime(C.chartTime(ms)));
+    const key = lines.join('|');
+    if (tipEl.dataset.k !== key) {
+      tipEl.dataset.k = key;
+      while (tipEl.firstChild) tipEl.removeChild(tipEl.firstChild);
+      lines.forEach((t, i) => tipEl.appendChild(el('div', i === 0 ? `h ${hit.m.side}` : i === lines.length - 1 ? `src ${hit.m.source}` : null, t)));
+    }
+    tipEl.hidden = false;
+    const w = chartEl.clientWidth;
+    const left = hit.x + 14 + 190 > w ? hit.x - 14 - tipEl.offsetWidth : hit.x + 14;
+    tipEl.style.left = `${Math.max(4, left)}px`; tipEl.style.top = `${Math.max(4, hit.y - 20)}px`;
   }
 
   function renderOverlays() {
@@ -281,7 +368,8 @@
     const pos = vm.position || null;
     if (pos && typeof pos.avgEntryUsd === 'number' && pos.avgEntryUsd > 0) {
       const pct = typeof pos.unrealizedPct === 'number' ? ` ${C.fmtPct(pos.unrealizedPct, 1)}` : '';
-      setLine('entry', { price: pos.avgEntryUsd, color: T.warn, lineWidth: 1, lineStyle: L.LineStyle.Solid, axisLabelVisible: true, axisLabelColor: T.warn, axisLabelTextColor: T.bg, title: `ENTRY ${pos.sizeLabel}${pct}` });
+      // task-1483: the average entry of the open position is a DASHED line (fills are the triangles)
+      setLine('entry', { price: pos.avgEntryUsd, color: pos.kind === 'paper' ? T.warn : T.text, lineWidth: 1, lineStyle: L.LineStyle.LargeDashed, axisLabelVisible: true, axisLabelColor: pos.kind === 'paper' ? T.warn : T.text, axisLabelTextColor: T.bg, title: `AVG ENTRY ${pos.sizeLabel}${pct}` });
     } else setLine('entry', null);
     setLine('stop', pos && typeof pos.stopUsd === 'number' && pos.stopUsd > 0 ? { price: pos.stopUsd, color: T.down, lineWidth: 1, lineStyle: L.LineStyle.Dashed, axisLabelVisible: true, title: 'STOP' } : null);
     setLine('target', pos && typeof pos.targetUsd === 'number' && pos.targetUsd > 0 ? { price: pos.targetUsd, color: T.up, lineWidth: 1, lineStyle: L.LineStyle.Dashed, axisLabelVisible: true, title: 'TARGET' } : null);
@@ -342,8 +430,14 @@
       r2.appendChild(s);
     }
     if (r2.firstChild) legendEl.appendChild(r2);
+    // task-1483: which markers are on screen, and what the window left off (never moved onto another bar)
+    if (S.marks && S.marks.on) {
+      const lg = C.markerLegend(S.marks.set.markers);
+      const om = C.omittedNote({ ...S.marks.set, before: S.marks.set.before + S.marks.truncated });
+      if (lg || om) { const r3 = el('div', 'row3'); if (lg) r3.appendChild(el('span', S.marks.set.markers.some((m) => m.source === 'paper') ? 'paper' : null, lg)); if (om) r3.appendChild(el('span', null, `${lg ? '  · ' : ''}${om}`)); legendEl.appendChild(r3); }
+    }
   }
-  chart.subscribeCrosshairMove((p) => { S.hover = p && p.time != null ? p.time : null; renderLegend(S.hover); });
+  chart.subscribeCrosshairMove((p) => { S.hover = p && p.time != null ? p.time : null; S.mouse = p && p.point ? { x: p.point.x, y: p.point.y } : null; renderLegend(S.hover); });
 
   // ---------------------------------------------------------------- header, LIVE badge, banner, position row
   function renderHeader() {
@@ -437,7 +531,7 @@
     // task-1366: a mode / supply change re-labels the axis in place (the bars are prices either way)
     const disp = C.displayOf(vm);
     if (disp.key !== S.display.key) { S.display = disp; applyPriceFormat(); }
-    if (tail && (!vm.seriesKey || vm.seriesKey !== S.key)) { S.vm = { ...vm, candles: [] }; renderHeader(); renderPosition(); renderChip(); renderOverlays(); return; }
+    if (tail && (!vm.seriesKey || vm.seriesKey !== S.key)) { S.vm = { ...vm, candles: [] }; renderHeader(); renderPosition(); renderChip(); renderOverlays(); computeMarks(); syncToolbar(); return; }
     const intervalChanged = vm.interval !== S.interval;
     S.interval = vm.interval;
     const answered = S.pendingInterval === vm.interval ? S.reqAt : null;
@@ -520,10 +614,12 @@
     dctx.clearRect(0, 0, w, h);
     const segs = S.drawings.filter((d) => d.kind === 't').map((d) => [d.a, d.b]);
     if (S.tPending && mouse) segs.push([S.tPending, mouse]);
-    if (!segs.length || !S.bars.length) return;
+    if (!S.bars.length) return;
     const ts = chart.timeScale(), s = active(), pS = periodMs() / 1000;
     const paneH = chart.panes()[0] ? chart.panes()[0].getHeight() : h;
     dctx.save(); dctx.beginPath(); dctx.rect(0, 0, ts.width(), paneH); dctx.clip();
+    drawMarks(ts, s, paneH); // task-1483
+    if (!segs.length) { dctx.restore(); return; }
     dctx.strokeStyle = T.accent; dctx.fillStyle = T.accent; dctx.lineWidth = 1.5;
     for (const [a, b] of segs) {
       const xa = ts.logicalToCoordinate(C.logicalOf(S.bars, a.time, pS)), xb = ts.logicalToCoordinate(C.logicalOf(S.bars, b.time, pS));
@@ -552,6 +648,7 @@
       case 'm': toggleInd('volma'); break;
       case 'v': toggleInd('volume'); break;
       case 'b': toggleInd('tape'); break;
+      case 'k': setMarkers(!(S.vm && S.vm.marks && S.vm.marks.on)); break; // task-1483
       case 'h': armDraw('h'); break;
       case 't': armDraw('t'); break;
       case 'x': clearDrawings(); break;

package/dist/packages/popup/src/protocol.js

@@ -30,4 +30,6 @@ export const CHART_STYLES = ['candles', 'line', 'area'];
 export const CHART_SCALES = ['auto', 'log', 'percent'];
 /** task-1472: what the chart's Y axis shows (the popup's MCAP | PRICE control / `A` ask the terminal to switch). */
 export const CHART_AXES = ['mcap', 'price'];
+/** The most fills one chart VM carries (newest kept). */
+export const CHART_MARKS_MAX = 500;
 export const PROTOCOL_VERSION = 'dexterm-popup/1';

package/dist/packages/popup/src/server.js

@@ -50,6 +50,8 @@ export const POPUP_EVENTS = new Set([
     'event:chart.interval', 'event:chart.indicator', 'event:chart.style', 'event:chart.scale', 'event:chart.painted',
     // task-1472: the chart's Y axis (market cap ⇄ price): a display preference the terminal saves, nothing else
     'event:chart.axis',
+    // task-1483: show / hide the chart's BUY / SELL markers (display.chartMarkers): a display preference, nothing else
+    'event:chart.markers',
     // task-1345 agent roster: per-agent pause / kick, by agent name (the only writes this popup can send)
     'event:roster.pause', 'event:roster.resume', 'event:roster.kick',
     // task-1355 order plans: cancel a plan by id (the ONLY write the plans popup can send — never arm/cap/sign)
@@ -98,6 +100,8 @@ export function validateEventPayload(name, payload) {
             return oneOf(CHART_SCALES, p.scale) ? { scale: p.scale } : null;
         case 'chart.axis':
             return oneOf(CHART_AXES, p.axis) ? { axis: p.axis } : null;
+        case 'chart.markers': // task-1483: show / hide the BUY / SELL markers (a display setting; nothing else)
+            return typeof p.on === 'boolean' ? { on: p.on } : null;
         case 'chart.painted':
             return (p.kind === 'first' || p.kind === 'data') && finiteIn(p.ms, 0, 600_000) && finiteIn(p.sentAt, 0, 1e15)
                 ? { kind: p.kind, ms: p.ms, sentAt: p.sentAt } : null;

package/dist/packages/recorder/src/index.js

@@ -9,6 +9,8 @@ export * from "./open.js";
 export * from "./verdicts.js";
 export * from "./schedule.js";
 export * from "./dev-history.js";
+export * from "./ticks.js";
+export * from "./retention.js";
 export { recorderCli, RECORDER_HELP } from "./cli.js";
 /** `--no-recorder` / `DEXTERM_RECORDER=0` resolution: the recorder is on in live mode unless either says no. */
 export function recorderEnabled(env, flagOff) {

package/dist/packages/recorder/src/recorder.js

@@ -7,7 +7,10 @@
 //             day, skipped while the bucket is paused after a 429. The only requests this package makes.
 //   label     code-only outcome labels per (t0 anchor, horizon) from the recorded numbers (labels.ts).
 //   prune     retention: raw JSON 7 d (focus rows only), one row per mint per minute after 24 h,
-//             columns 90 d, outcomes/verdicts forever.
+//             columns 90 d, outcomes/verdicts forever; autotrade ticks 14 d, sampled candles 90 d.
+//   ticks     (task-1504, opt-in) position-grade samples every 5–10 s for held / open / candidate / watch coins
+//             (ticks.ts), and a DB cap enforced by evicting the oldest history (retention.ts) instead of
+//             pausing observation.
 // Everything is synchronous SQLite on the app's own DB file (node:sqlite, WAL), batched in transactions,
 // so a refresh never awaits the recorder and a crash loses at most one batch.
 import { mkdirSync } from 'node:fs';
@@ -18,8 +21,10 @@ import { ALL_HORIZONS_MASK, HORIZONS_SEC, SCHEMA_SQL, SCHEMA_VERSION } from "./s
 import { COLUMN_NAMES, fromDsView, fromEnrichedRow, isMaterialChange } from "./snapshot.js";
 import { LABELER_VERSION, labelAtHorizon } from "./labels.js";
 import { dueBounds, selectDue } from "./sweep.js";
+import { TickLane } from "./ticks.js";
+import { DEFAULT_AGE, enforceCap, pruneTicksByAge } from "./retention.js";
 export const DEFAULT_SWEEP = { everyMs: 60_000, maxCallsPerSweep: 6, maxCallsPerDay: 1500, batch: 30 };
-export const DEFAULT_RETENTION = { rawDays: 7, columnsDays: 90, downsampleAfterHours: 24, everyMs: 3_600_000 };
+export const DEFAULT_RETENTION = { rawDays: 7, columnsDays: 90, downsampleAfterHours: 24, everyMs: 3_600_000, ...DEFAULT_AGE };
 /** Unchanged rows are re-written this often at most; the horizons are ≥ 1 h, so 30 min keeps every window observed. */
 export const DEFAULT_HEARTBEAT_MS = 1_800_000;
 export const DEFAULT_T0_EVERY_MS = 3_600_000;
@@ -43,6 +48,9 @@ export class Recorder {
     membersEveryMs;
     sweepPolicy;
     retention;
+    /** task-1504: the tick lane (null when not configured) and the cap policy (null = no cap). */
+    tickLane;
+    cap;
     onLog;
     /**
      * Per mint: the last WRITTEN row (columns + hash + time) and the newest observation time this process
@@ -92,6 +100,8 @@ export class Recorder {
             lastLive: this.db.prepare(`SELECT t, hash, sources, ${cols} FROM token_snapshots WHERE mint = ? AND kind = 'live' ORDER BY t DESC LIMIT 1`),
             insertCreator: this.db.prepare('INSERT OR IGNORE INTO creators (mint, creator, source, first_t, created_at) VALUES (?, ?, ?, ?, ?)'),
         };
+        this.tickLane = opts.ticks ? new TickLane(this.db, { focus: opts.ticks.focus, policy: opts.ticks.policy, clock: this.clock, onLog: this.onLog }) : null;
+        this.cap = opts.cap && opts.cap.maxBytes ? opts.cap : null;
     }
     /** Attach as the data layer's store listener (and detach any previous one). */
     attach(store) {
@@ -298,8 +308,38 @@ export class Recorder {
         catch (err) {
             this.log(`prune failed: ${msg(err)}`);
         }
+        try {
+            this.enforceCap(now);
+        }
+        catch (err) {
+            this.log(`cap failed: ${msg(err)}`);
+        }
         return out;
     }
+    /**
+     * task-1504: one tick-lane poll (ticks.ts). The host calls it every `fastEveryMs` (5 s); 'disabled' when the
+     * recorder is off or no tick lane was configured. The only other requests this package makes besides sweeps.
+     */
+    async pollTicks(deps, now = this.clock.now()) {
+        if (!this.enabled || this.closed || !this.tickLane)
+            return { coins: 0, calls: 0, answered: 0, written: 0, overCap: 0, skipped: 'disabled' };
+        return this.tickLane.poll(deps, now);
+    }
+    /**
+     * task-1504: keep the DB under the configured cap by evicting the oldest history (retention.ts). A no-op without
+     * a cap or below its high-water mark. Observation never pauses; the collector calls this before each pass.
+     */
+    enforceCap(now = this.clock.now()) {
+        if (!this.cap || this.closed)
+            return null;
+        const r = enforceCap(this.db, this.cap, now);
+        if (r.evicted) {
+            this.log(`cap: used ${(r.usedBefore / 1e6).toFixed(1)} → ${(r.usedAfter / 1e6).toFixed(1)} MB (${r.reclaimed} reclaimed, ${r.slices} slice(s) of history), history now from ${r.cutoff === null ? '—' : new Date(r.cutoff).toISOString()}${r.over ? ' (still over: only the newest hour is left)' : ''}`);
+            // Forget cached last rows: an evicted mint is re-seeded from the DB (or written fresh) next time.
+            this.seen.clear();
+        }
+        return r;
+    }
     /** Mints whose horizon window is open and unobserved (sweep.ts), soonest-closing first. */
     due(now = this.clock.now(), max = this.sweepPolicy.maxCallsPerSweep * this.sweepPolicy.batch) {
         const b = dueBounds(now);
@@ -455,7 +495,7 @@ export class Recorder {
      * watermark in recorder_meta means each pass only looks at the hours that newly crossed the line.
      */
     prune(now = this.clock.now()) {
-        const res = { rawCleared: 0, downsampled: 0, expired: 0, membersExpired: 0 };
+        const res = { rawCleared: 0, downsampled: 0, expired: 0, membersExpired: 0, ticksExpired: 0, candlesExpired: 0 };
         if (this.closed)
             return res;
         const day = 86_400_000;
@@ -480,14 +520,17 @@ export class Recorder {
             res.membersExpired = Number(this.db.prepare('DELETE FROM feed_members WHERE t < ?').run(colsBefore).changes);
             this.db.prepare('DELETE FROM mints WHERE last_any_t < ?').run(colsBefore);
             this.db.prepare('DELETE FROM sweeps WHERE started_at < ?').run(colsBefore);
+            const tk = pruneTicksByAge(this.db, { ticksDays: this.retention.ticksDays, candlesDays: this.retention.candlesDays }, now);
+            res.ticksExpired = tk.ticks;
+            res.candlesExpired = tk.candles;
             this.db.exec('COMMIT');
         }
         catch (err) {
             this.db.exec('ROLLBACK');
             throw err;
         }
-        if (res.rawCleared || res.downsampled || res.expired)
-            this.log(`prune: raw ${res.rawCleared}, downsampled ${res.downsampled}, expired ${res.expired} rows`);
+        if (res.rawCleared || res.downsampled || res.expired || res.ticksExpired)
+            this.log(`prune: raw ${res.rawCleared}, downsampled ${res.downsampled}, expired ${res.expired} rows, ${res.ticksExpired} ticks`);
         return res;
     }
     // ---------------------------------------------------------------- read side
@@ -512,7 +555,7 @@ export class Recorder {
             const d = one("SELECT SUM(pgsize) AS b FROM dbstat WHERE name IN ('token_snapshots', 'token_snapshots_mint_t', 'token_snapshots_t', 'token_snapshots_t0_pending')");
             if (d.b !== null && Number(s.n) > 0)
                 bytesPerSnapshot = Number(d.b) / Number(s.n);
-            const all = one("SELECT SUM(pgsize) AS b FROM dbstat WHERE name IN ('recorder_meta', 'feed_members', 'feed_members_mint_t', 'token_snapshots', 'token_snapshots_mint_t', 'token_snapshots_t', 'token_snapshots_t0_pending', 'mints', 'mints_last_live', 'sweeps', 'chain_events', 'chain_events_mint_t', 'outcomes', 'outcomes_label', 'verdicts', 'verdicts_mint_t')");
+            const all = one("SELECT SUM(pgsize) AS b FROM dbstat WHERE name IN ('recorder_meta', 'feed_members', 'feed_members_mint_t', 'token_snapshots', 'token_snapshots_mint_t', 'token_snapshots_t', 'token_snapshots_t0_pending', 'mints', 'mints_last_live', 'sweeps', 'chain_events', 'chain_events_mint_t', 'outcomes', 'outcomes_label', 'verdicts', 'verdicts_mint_t', 'creators', 'creators_creator', 'autotrade_ticks', 'autotrade_ticks_t', 'autotrade_candles_1m', 'autotrade_candles_1m_t')");
             recorderBytes = all.b === null ? null : Number(all.b);
         }
         catch {
@@ -533,6 +576,9 @@ export class Recorder {
             outcomesByLabel: byLabel,
             sweeps: Number(one('SELECT COUNT(*) AS n FROM sweeps').n),
             sweepCallsToday: this.sweepCallsToday(now),
+            ticks: Number(one('SELECT COUNT(*) AS n FROM autotrade_ticks').n),
+            candles: Number(one('SELECT COUNT(*) AS n FROM autotrade_candles_1m').n),
+            tickCallsToday: this.tickLane ? this.tickLane.callsToday(now) : tickCallsOn(this.db, now),
             dbBytes, recorderBytes, bytesPerSnapshot,
             oldestT: s.oldest === null ? null : Number(s.oldest),
             newestT: s.newest === null ? null : Number(s.newest),
@@ -571,6 +617,17 @@ export class Recorder {
         this.onLog?.(`recorder: ${line}\n`);
     }
 }
+/** Tick calls the lane recorded for `now`'s UTC day (recorder_meta), for a reader with no lane of its own. */
+function tickCallsOn(db, now) {
+    const r = db.prepare("SELECT value FROM recorder_meta WHERE key = 'tick_calls'").get();
+    try {
+        const v = r ? JSON.parse(r.value) : null;
+        return v && v.day === new Date(now).toISOString().slice(0, 10) ? Number(v.calls) || 0 : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 function msg(err) {
     return err instanceof Error ? err.message : String(err);
 }

package/dist/packages/recorder/src/retention.js

@@ -0,0 +1,100 @@
+// dexterm history recorder: retention under a DB cap (task-1504, AUTOTRADE-SPEC §3 + §10 Q4).
+//
+// Before this, the collector's only answer to a full disk was to PAUSE observation above `--max-db-mb`, while the
+// outcome sweeps kept writing: the cap stopped exactly the rows autotrade needs and the DB still grew past it.
+// This module keeps the DB under the cap by EVICTING the oldest recorder history instead, so observation never
+// pauses:
+//
+//   age       ticks after `ticksDays` (14), sampled candles after `candlesDays` (90). Snapshot / feed-member /
+//             sweep rows keep the recorder's existing `columnsDays` rule (recorder.ts prune; Q4's "prune raw rows
+//             older than 14 days" is `columnsDays: 14`).
+//   reclaim   (optional) once the cap is reached, the host's cheap space goes first: the collector passes the data
+//             layer's own expired-cache prune (`Cache.prune()`, entries a day past their TTL), measured on
+//             2026-10-21 at ~470 MB of a 1,173 MB file that only held ~430 MB of recorder history.
+//   cap       once the DB's USED bytes (pages minus the freelist) reach `highWater` × `maxBytes`, delete the
+//             oldest slice of history (`sliceMs`, all recorder tables: ticks, candles, snapshots incl. sweep rows,
+//             feed members; the small sweep ledger keeps its age rule) and repeat until used ≤ `lowWater` × `maxBytes`. Rows newer than
+//             `keepMs` are never evicted. Outcomes, verdicts and creators are tiny and stay forever.
+//
+// SQLite does not shrink the file on DELETE: freed pages go to the freelist and new rows reuse them. So the file
+// stops growing at about the high-water mark; a file that is ALREADY above the cap stays that size (only
+// `VACUUM`, with the collector stopped, gives the space back) but no longer grows.
+export const DEFAULT_CAP = { maxBytes: null, highWater: 0.95, lowWater: 0.85, sliceMs: 3_600_000, keepMs: 3_600_000, maxSlices: 500 };
+export const DEFAULT_AGE = { ticksDays: 14, candlesDays: 90 };
+/** The Q4 default cap when retention-by-cap is switched on (3 GB). */
+export const DEFAULT_CAP_BYTES = 3_000_000_000;
+/** Tables the cap may evict from, each with its time column. */
+const EVICTABLE = [
+    { table: 'autotrade_ticks', col: 't' },
+    { table: 'autotrade_candles_1m', col: 't' },
+    { table: 'token_snapshots', col: 't' },
+    { table: 'feed_members', col: 't' },
+];
+export function dbSize(db) {
+    const one = (sql) => Number(Object.values(db.prepare(sql).get())[0]);
+    const ps = one('PRAGMA page_size');
+    const pc = one('PRAGMA page_count');
+    const fl = one('PRAGMA freelist_count');
+    return { fileBytes: pc * ps, usedBytes: (pc - fl) * ps };
+}
+/**
+ * Enforce the cap: a no-op below the high-water mark; above it, delete the oldest `sliceMs` of history across every
+ * evictable table, one transaction per slice, until used ≤ the low-water mark. Never deletes rows newer than
+ * `now - keepMs`. Outcome / verdict / creator rows are never touched.
+ */
+export function enforceCap(db, policy, now) {
+    const p = { ...DEFAULT_CAP, ...policy };
+    const size0 = dbSize(db);
+    const res = { evicted: false, usedBefore: size0.usedBytes, usedAfter: size0.usedBytes, fileBytes: size0.fileBytes, slices: 0, reclaimed: 0, deleted: {}, cutoff: null, over: false };
+    if (p.maxBytes === null || p.maxBytes <= 0 || size0.usedBytes < p.highWater * p.maxBytes)
+        return res;
+    res.evicted = true;
+    const target = p.lowWater * p.maxBytes;
+    const floor = now - p.keepMs;
+    const tables = EVICTABLE.filter((e) => !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(e.table));
+    const oldestQ = tables.map((e) => ({ ...e, q: db.prepare(`SELECT MIN(${e.col}) AS m FROM ${e.table}`), del: db.prepare(`DELETE FROM ${e.table} WHERE ${e.col} < ?`) }));
+    const delMints = db.prepare('DELETE FROM mints WHERE last_any_t < ?');
+    let used = size0.usedBytes;
+    if (p.reclaim) {
+        res.reclaimed = p.reclaim();
+        used = dbSize(db).usedBytes;
+    }
+    while (used > target && res.slices < p.maxSlices) {
+        let oldest = Infinity;
+        for (const e of oldestQ) {
+            const m = e.q.get().m;
+            if (m !== null && Number(m) < oldest)
+                oldest = Number(m);
+        }
+        if (!Number.isFinite(oldest) || oldest >= floor)
+            break;
+        const cutoff = Math.min(oldest + p.sliceMs, floor);
+        db.exec('BEGIN');
+        try {
+            for (const e of oldestQ)
+                res.deleted[e.table] = (res.deleted[e.table] ?? 0) + Number(e.del.run(cutoff).changes);
+            res.deleted.mints = (res.deleted.mints ?? 0) + Number(delMints.run(cutoff).changes);
+            db.exec('COMMIT');
+        }
+        catch (err) {
+            db.exec('ROLLBACK');
+            throw err;
+        }
+        res.slices++;
+        res.cutoff = cutoff;
+        used = dbSize(db).usedBytes;
+    }
+    const size1 = dbSize(db);
+    res.usedAfter = size1.usedBytes;
+    res.fileBytes = size1.fileBytes;
+    res.over = size1.usedBytes >= p.highWater * p.maxBytes;
+    return res;
+}
+/** Age rules for the autotrade tables (the recorder's prune() calls this next to its own snapshot rules). */
+export function pruneTicksByAge(db, policy, now) {
+    const p = { ...DEFAULT_AGE, ...policy };
+    const day = 86_400_000;
+    const ticks = Number(db.prepare('DELETE FROM autotrade_ticks WHERE t < ?').run(now - p.ticksDays * day).changes);
+    const candles = Number(db.prepare('DELETE FROM autotrade_candles_1m WHERE t < ?').run(now - p.candlesDays * day).changes);
+    return { ticks, candles };
+}

package/dist/packages/recorder/src/schema.js

@@ -12,7 +12,11 @@
 //   - `mints` is a per-mint summary the sweep scheduler reads instead of scanning snapshots.
 //   - feed_members is keyed on (t, feed, rank): the refresh tick is the run.
 //   - chain_events and verdicts are created here (one schema owner) but written by R-02 / L-01.
-export const SCHEMA_VERSION = 1;
+//
+// v2 (task-1504, AUTOTRADE-SPEC §3): `autotrade_ticks` (position-grade samples every 5–10 s for the few coins
+// that are watched, open, a candidate or held; written by the tick lane in ticks.ts) and `autotrade_candles_1m`
+// (1-minute OHLC built from those samples). Both are additive: a v1 file gains the two tables on open.
+export const SCHEMA_VERSION = 2;
 export const HORIZONS_SEC = [3600, 7200, 21600, 86400, 259200];
 /** Every horizon labelled: the bitmask value of `horizons_done` for a finished t0 row. */
 export const ALL_HORIZONS_MASK = (1 << HORIZONS_SEC.length) - 1;
@@ -143,4 +147,33 @@ CREATE TABLE IF NOT EXISTS creators (
   created_at  INTEGER                    -- the coin's creation time when the source gave one
 ) WITHOUT ROWID;
 CREATE INDEX IF NOT EXISTS creators_creator ON creators (creator, first_t);
+
+-- task-1504 (AUTOTRADE-SPEC §3): position-grade ticks. One row per (mint, poll) for focus coins, written
+-- every sample (no change detection), from DexScreener tokens/v1 batches. price_usd NULL = the poll got no
+-- pair back for the mint (pool gone or not indexed): a held coin's rug shows up here as NULL rows.
+CREATE TABLE IF NOT EXISTS autotrade_ticks (
+  mint            TEXT NOT NULL,
+  t               INTEGER NOT NULL,          -- unix ms the answer was fetched
+  role            TEXT NOT NULL,             -- why it was polled: 'held' | 'open' | 'candidate' | 'watch'
+  price_usd REAL, liquidity_usd REAL, mcap REAL, fdv REAL,
+  vol_m5 REAL, vol_h1 REAL,
+  buys_m5 INTEGER, sells_m5 INTEGER,
+  chg_m5 REAL, chg_h1 REAL,
+  pair_address    TEXT,
+  pair_created_at INTEGER,
+  PRIMARY KEY (mint, t)
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS autotrade_ticks_t ON autotrade_ticks (t);
+
+-- 1-minute candles for the same coins, built from the ticks (sampled: high/low are of the 5–10 s samples,
+-- not of every trade). t = the minute's start; n = samples in the minute.
+CREATE TABLE IF NOT EXISTS autotrade_candles_1m (
+  mint  TEXT NOT NULL,
+  t     INTEGER NOT NULL,
+  o REAL NOT NULL, h REAL NOT NULL, l REAL NOT NULL, c REAL NOT NULL,
+  liq_c REAL, mcap_c REAL,
+  n     INTEGER NOT NULL,
+  PRIMARY KEY (mint, t)
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS autotrade_candles_1m_t ON autotrade_candles_1m (t);
 `;