dexterm-cli 0.1.4 → 0.1.6

package/dist/packages/cli/src/mcp-follow.js

@@ -14,11 +14,52 @@
 // kill" are local follow controls: pause/take-over stop the terminal mirroring the agent (the external agent
 // keeps running — we simply stop moving the screen), and kill removes the rendezvous so the server stops
 // emitting. Any user keypress during an agent move takes control, so the human and the agent never fight.
-import { writeFileSync, readFileSync, rmSync, mkdirSync, statSync } from 'node:fs';
+import { writeFileSync, readFileSync, rmSync, mkdirSync, statSync, openSync, readSync, closeSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { SpectatorHub, FollowController, SpectatorServer, } from '../../agents/src/index.js';
-import { rendezvousPath } from '../../mcp/src/index.js';
+import { SpectatorHub, FollowController, SpectatorServer, AgentStory, sanitizeDetail, } from '../../agents/src/index.js';
+import { rendezvousPath, writeFollowScreen, clearFollowScreen } from '../../mcp/src/index.js';
+/**
+ * task-1466: the agent's own words in one JSONL line of a thoughts feed. Understands Claude Code stream-json
+ * (`assistant` messages: text and thinking blocks), the capture harness's brain feed (`{tEpoch, ev}` wrapping one),
+ * and plain `{"thought": "…"}` / `{"text": "…"}` lines. Anything else yields nothing. Text only; never acted on.
+ */
+export function thoughtsOf(line) {
+    const s = line.trim();
+    if (!s || s[0] !== '{' || s.length > 200_000)
+        return [];
+    let o;
+    try {
+        o = JSON.parse(s);
+    }
+    catch {
+        return [];
+    }
+    let t = typeof o.tEpoch === 'number' && Number.isFinite(o.tEpoch) ? o.tEpoch : null;
+    if (o.ev && typeof o.ev === 'object')
+        o = o.ev;
+    if (t === null && typeof o.t === 'number' && Number.isFinite(o.t) && o.t > 1e12)
+        t = o.t;
+    // task-1473: a demo / stand-in feed marks its scripted lines `"demo": true` (the brain view tags them "demo text")
+    if (typeof o.thought === 'string')
+        return [{ text: o.thought, t, ...(o.demo === true ? { demo: true } : {}) }];
+    if (o.type === 'assistant' && o.message && typeof o.message === 'object') {
+        const content = o.message.content;
+        if (!Array.isArray(content))
+            return [];
+        const out = [];
+        for (const b of content) {
+            if (b?.type === 'text' && typeof b.text === 'string')
+                out.push({ text: b.text, t });
+            else if (b?.type === 'thinking' && typeof b.thinking === 'string' && b.thinking.trim())
+                out.push({ text: b.thinking, t });
+        }
+        return out;
+    }
+    if (typeof o.text === 'string' && !o.type)
+        return [{ text: o.text, t }];
+    return [];
+}
 function navLabel(agent, nav) {
     const coin = nav.mint ? ` ${nav.mint.length > 10 ? nav.mint.slice(0, 4) + '…' + nav.mint.slice(-4) : nav.mint}` : '';
     if (nav.screen === 'token')
@@ -45,6 +86,8 @@ function navLabel(agent, nav) {
 export class McpFollowSession {
     hub;
     follow;
+    /** task-1466: the story the spectator v2 HUD draws (phase rail, timeline, thoughts, PAPER trade arc). */
+    story;
     opts;
     rvPath;
     channelPath;
@@ -52,10 +95,12 @@ export class McpFollowSession {
     agentLabel;
     currentAgent;
     offset = 0;
+    thoughtsOffset = 0;
     timer = null;
     stream = null;
     armed = false;
     paused = false;
+    lastSnapshot = 0;
     constructor(opts) {
         this.opts = opts;
         this.agentLabel = opts.agentLabel || 'mcp-agent';
@@ -70,7 +115,8 @@ export class McpFollowSession {
             kickAgent: () => { this.disarm(); return 1; },
         };
         this.follow = new FollowController({ controls, activityCap: Math.max(1, opts.activityCap ?? 200) });
-        this.hub.on((ev) => this.follow.apply(ev));
+        this.story = new AgentStory(this.agentLabel);
+        this.hub.on((ev) => { this.follow.apply(ev); this.story.apply(ev); });
     }
     /** Arm the rendezvous (so a `dexterm mcp` server starts emitting) and begin tailing. Idempotent. */
     async start() {
@@ -85,10 +131,23 @@ export class McpFollowSession {
             }
         }
         if (!this.timer) {
-            this.timer = setInterval(() => this.pump(), Math.max(30, this.opts.pollMs ?? 150));
+            this.timer = setInterval(() => { this.pump(); this.publish(); }, Math.max(30, this.opts.pollMs ?? 150));
             this.timer.unref?.();
         }
     }
+    /** Publish the follow-mode screen snapshot (throttled to ~1/s; only while armed). Never throws. */
+    publish(force = false) {
+        if (!this.opts.snapshot || !this.armed)
+            return;
+        const now = (this.opts.now ?? Date.now)();
+        if (!force && now - this.lastSnapshot < 1000)
+            return;
+        this.lastSnapshot = now;
+        try {
+            writeFollowScreen(this.opts.env, this.opts.snapshot());
+        }
+        catch { /* fail closed: stale → nav refused */ }
+    }
     /** Write (or re-write) the channel + rendezvous so the server emits here. */
     rearm() {
         try {
@@ -108,14 +167,62 @@ export class McpFollowSession {
             // A second follow surface may have replaced the rendezvous after this session started.  Never remove
             // another surface's live handle when this one pauses, is killed, or exits.
             const current = JSON.parse(readFileSync(this.rvPath, 'utf8'));
-            if (current.token === this.token)
+            if (current.token === this.token) {
                 rmSync(this.rvPath, { force: true });
+                if (this.opts.snapshot)
+                    clearFollowScreen(this.opts.env);
+            }
         }
         catch { /* absent/malformed/another surface owns it */ }
         this.armed = false;
     }
     /** Read and fold any records appended since the last pump. Public so tests can drive it without timers. */
     pump() {
+        this.pumpThoughts();
+        this.pumpChannel();
+    }
+    /** task-1466: new lines of the agent's own words → the story's thought ribbon (bounded: ≤ 256 KB per pump). */
+    pumpThoughts() {
+        const file = this.opts.thoughtsFile;
+        if (!file)
+            return;
+        let text;
+        try {
+            const st = statSync(file);
+            if (st.size < this.thoughtsOffset)
+                this.thoughtsOffset = 0;
+            if (st.size === this.thoughtsOffset)
+                return;
+            if (st.size - this.thoughtsOffset > 256 * 1024)
+                this.thoughtsOffset = st.size - 256 * 1024; // skip a backlog, keep the tail
+            const fd = openSync(file, 'r');
+            try {
+                const buf = Buffer.alloc(st.size - this.thoughtsOffset);
+                readSync(fd, buf, 0, buf.length, this.thoughtsOffset);
+                text = buf.toString('utf8');
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        catch {
+            return;
+        }
+        const nl = text.lastIndexOf('\n');
+        if (nl < 0)
+            return;
+        this.thoughtsOffset += Buffer.byteLength(text.slice(0, nl + 1), 'utf8');
+        const now = (this.opts.now ?? Date.now)();
+        for (const line of text.slice(0, nl).split('\n')) {
+            for (const th of thoughtsOf(line))
+                this.story.thought(th.text, th.t ?? now, 'agent', th.demo === true);
+        }
+        try {
+            this.opts.onEvent?.();
+        }
+        catch { /* ignore */ }
+    }
+    pumpChannel() {
         let text;
         try {
             const st = statSync(this.channelPath);
@@ -167,6 +274,7 @@ export class McpFollowSession {
             ms: rec.ms ?? null,
             dataAgeSec: rec.dataAgeSec ?? null,
             nav: rec.nav ?? null,
+            detail: sanitizeDetail(rec.detail),
             ok: rec.ok ?? true,
             t: typeof rec.t === 'number' ? rec.t : undefined,
         });
@@ -182,6 +290,15 @@ export class McpFollowSession {
             }
             catch { /* ignore */ }
         }
+        // task-1443: every agent PAPER write (fill, close, size, or a refusal) is toasted in the terminal, whatever the
+        // follow state, so the watcher always sees what the agent did to the simulated ledger.
+        if (typeof ev.tool === 'string' && /^paper_(open_ticket|size_ticket|confirm|close)$/.test(ev.tool)) {
+            const what = ev.ok === false ? `PAPER ${ev.tool.slice(6).replace('_', ' ')} refused · ${String(ev.summary ?? '').replace(/^error: /, '').slice(0, 70)}` : String(ev.summary ?? ev.tool);
+            try {
+                this.opts.onStatus?.(`agent ${this.currentAgent}: ${what}`);
+            }
+            catch { /* ignore */ }
+        }
         try {
             this.opts.onEvent?.();
         }
@@ -195,10 +312,18 @@ export class McpFollowSession {
         return !st || st.status === 'active';
     }
     // ----- the owner's controls. Each returns a short line to toast. -----
-    pause() { const l = this.follow.pause(this.currentAgent); this.paused = l.startsWith('paused '); this.opts.onStatus?.(l); return l; }
-    takeOver() { const l = this.follow.takeOver(this.currentAgent); this.paused = false; this.opts.onStatus?.(l); return l; }
-    resume() { const l = this.follow.resume(this.currentAgent); this.paused = false; this.opts.onStatus?.(l); return l; }
-    kill() { const l = this.follow.kill(this.currentAgent); this.paused = false; this.opts.onStatus?.(l); return l; }
+    pause() { const l = this.follow.pause(this.currentAgent); this.paused = l.startsWith('paused '); this.control('paused'); this.opts.onStatus?.(l); return l; }
+    takeOver() { const l = this.follow.takeOver(this.currentAgent); this.paused = false; this.control('takeover'); this.opts.onStatus?.(l); return l; }
+    resume() { const l = this.follow.resume(this.currentAgent); this.paused = false; this.control('running'); this.opts.onStatus?.(l); return l; }
+    kill() { const l = this.follow.kill(this.currentAgent); this.paused = false; this.control('stopped'); this.opts.onStatus?.(l); return l; }
+    control(state) {
+        const now = (this.opts.now ?? Date.now)();
+        this.story.setControl(state === 'stopped' ? 'killed' : state, now);
+        try {
+            this.opts.onControl?.(state);
+        }
+        catch { /* never breaks the key loop */ }
+    }
     /** Any physical keypress while the agent is driving: the human takes over (no fight over the screen). */
     userKey() { if (this.follow.controlState === 'agent')
         this.takeOver(); }
@@ -207,6 +332,8 @@ export class McpFollowSession {
     get screenModel() { return this.follow.screenModel; }
     get streamPort() { return this.stream?.port ?? 0; }
     view() { return this.follow.view(); }
+    /** task-1466: the story at `now` for the HUD. */
+    storyView(now = (this.opts.now ?? Date.now)()) { return this.story.view(now); }
     /** Tear down: stop the timer, remove the rendezvous, close the stream. Safe to call more than once. */
     async stop() {
         if (this.timer) {

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

@@ -9,6 +9,7 @@
 //   dexterm plan journal [--verify] [--export]
 //   dexterm mandate draft [--total 100] [--per-trade 20] [--per-coin 40] [--daily-loss 50]
 //                         [--max-tier keypress|ptt-held|hands-free] [--ttl-hours 4]
+//                         [--max-open 20] [--max-impact 3] [--paper]
 //   dexterm mandate list [--json] | arm <id> | revoke <id>
 //
 // Arming is the only gate: `arm` reads ONE real keystroke in raw mode (ttyKeypress) and refuses a pipe,
@@ -44,7 +45,10 @@ const PLAN_USAGE = `dexterm plan <command>
   journal [--verify] [--export]`;
 const MANDATE_USAGE = `dexterm mandate <command>
   draft [--total 100] [--per-trade 20] [--per-coin 40] [--daily-loss 50]
-        [--max-tier keypress|ptt-held|hands-free] [--ttl-hours 4] [--json]
+        [--max-tier keypress|ptt-held|hands-free] [--ttl-hours 4] [--max-open 20] [--max-impact 3]
+        [--paper] [--json]
+                                     (--paper: a PAPER-ONLY mandate for the agent paper desk, with its own
+                                      paper ceilings; no plan, copy trade or signer can ever use it)
   list [--json]
   arm <id>                           (needs a physical keypress on a TTY; a pipe/agent is refused)
   revoke <id>`;
@@ -203,16 +207,20 @@ export async function runMandate(rest, io) {
                 const num = (n) => (flag(rest, n) !== undefined ? parseAmount(flag(rest, n)) : undefined);
                 const maxTier = flag(rest, '--max-tier');
                 const ttlHours = flag(rest, '--ttl-hours') ? Number(flag(rest, '--ttl-hours')) : undefined;
+                const plain = (n) => (flag(rest, n) !== undefined ? Number(flag(rest, n)) : undefined);
                 const m = svc.draftMandate({
                     totalUsd: num('--total'), perTradeUsd: num('--per-trade'), perCoinUsd: num('--per-coin'),
                     dailyLossUsd: num('--daily-loss'), maxTier, ttlMs: ttlHours ? ttlHours * 3600_000 : undefined,
+                    maxOpenPositions: plain('--max-open'), maxPriceImpactPct: plain('--max-impact'),
+                    ...(has(rest, '--paper') ? { paperOnly: true } : {}),
                 });
                 if (has(rest, '--json')) {
-                    out(JSON.stringify({ id: m.id, budget: m.budget, maxTier: m.maxTier }));
+                    out(JSON.stringify({ id: m.id, budget: m.budget, maxTier: m.maxTier, paperOnly: m.paperOnly === true }));
                     return 0;
                 }
-                out(`drafted ${m.id}`);
+                out(`drafted ${m.id}${m.paperOnly ? '  (PAPER-ONLY: agent paper desk only)' : ''}`);
                 out(`  total ${fmtUsd(m.budget.totalUsd)} · per-trade ${fmtUsd(m.budget.perTradeUsd)} · per-coin ${fmtUsd(m.budget.perCoinUsd)} · daily-loss ${fmtUsd(m.budget.dailyLossUsd)} · maxTier ${m.maxTier}`);
+                out(`  max open ${m.limits.maxOpenPositions} · max price impact ${m.limits.maxPriceImpactPct}%`);
                 out('  DRAFT only — not armed. Arm with: dexterm mandate arm ' + m.id + '  (physical keypress)');
                 return 0;
             }
@@ -228,7 +236,7 @@ export async function runMandate(rest, io) {
                     return 0;
                 }
                 for (const r of rows)
-                    out(`${r.id.padEnd(24)} ${r.status.padEnd(7)} total ${fmtUsd(r.totalUsd)} · reserved ${fmtUsd(r.reservedUsd)} · spent ${fmtUsd(r.spentUsd)} · maxTier ${r.maxTier}`);
+                    out(`${r.id.padEnd(24)} ${r.status.padEnd(7)} total ${fmtUsd(r.totalUsd)} · reserved ${fmtUsd(r.reservedUsd)} · spent ${fmtUsd(r.spentUsd)} · maxTier ${r.maxTier}${r.paperOnly ? ' · PAPER-ONLY' : ''}`);
                 return 0;
             }
             case 'arm': {
@@ -243,7 +251,9 @@ export async function runMandate(rest, io) {
                     errOut(`no such mandate ${id}`);
                     return 1;
                 }
-                out(`Arm standing mandate ${id}? This lets armed plans fire at machine speed from the capped fast wallet.`);
+                out(row.paperOnly
+                    ? `Arm PAPER-ONLY mandate ${id}? This lets the agent paper desk book simulated fills under these caps. No plan, copy trade or signer can use it.`
+                    : `Arm standing mandate ${id}? This lets armed plans fire at machine speed from the capped fast wallet.`);
                 out(`  total ${fmtUsd(row.totalUsd)} · per-trade ${fmtUsd(row.perTradeUsd)} · per-coin ${fmtUsd(row.perCoinUsd)} · maxTier ${row.maxTier}`);
                 out('Hold any key to confirm (physical keypress). A pipe or agent cannot arm. Waiting 15s…');
                 const key = await ttyKeypress(io.stdin, 15_000);

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

@@ -14,6 +14,7 @@ import { fmtPrice, fmtNum } from '../../tui/src/index.js';
 import { positionRow } from "./live/trade.js";
 import { signedUsd, signedPctOf, fmtUsdFine, sol as fmtSol, signedSol } from "./screens/positions.js";
 import { supplyRatio, positionPriceCells } from "./display.js";
+import { chipSegments } from "./screens/pnl-chip.js";
 /** Map the app's active Theme to the popup protocol's theme-token subset. */
 export function popupThemeFrom(t) {
     return {
@@ -160,6 +161,12 @@ export function tokenDetailVMFromView(v, intel = null) {
         flags: v.flags.map((f) => String(f)), holdersSample: v.holdersSample, updatedAt: v.updatedAt,
     };
 }
+/** task-1473 r2: the chip as the chart page draws it (same segments as the terminal). */
+export function chartChipFrom(m) {
+    if (!m)
+        return null;
+    return { kind: m.kind, symbol: m.symbol, tone: m.pnlPct === null ? 'muted' : m.pnlPct >= 0 ? 'up' : 'down', newPeak: m.newPeak, segments: chipSegments(m) };
+}
 /** "docked right of Terminal" / "screen right (unknown terminal)" — for the TUI toast. */
 export function describeDock(p) {
     if (!p)
@@ -432,6 +439,14 @@ export class TokenPopups {
             case 'chart.scale':
                 this.prefs = { ...this.prefs, scale: p.scale };
                 return;
+            case 'chart.axis': { // task-1472: a display preference the terminal saves; nothing else
+                if (p.axis !== 'mcap' && p.axis !== 'price')
+                    return;
+                this.source?.setChartAxis?.(p.axis);
+                if (this.lastView)
+                    this.push(this.lastView);
+                return;
+            }
             case 'chart.painted': {
                 const ms = Number(p.ms);
                 if (p.kind === 'first' && this.metrics.openedAt !== null && this.metrics.openToFirstPaintMs === null)
@@ -520,8 +535,9 @@ export class TokenPopups {
             prefs: this.prefs,
             now: this.now(),
             image: src.imagePath?.(view) ?? null,
-            priceMode: src.priceMode?.() ?? 'price',
+            priceMode: src.chartAxis?.() ?? src.priceMode?.() ?? 'price', // task-1472: the chart axis drives the popup
         });
+        vm.chip = chartChipFrom(src.pnlChip?.() ?? null); // task-1473 r2
         const key = vm.seriesKey ?? null;
         const n = vm.candles.length;
         const canTail = !full && this.ready && key !== null && key === this.lastKey && this.lastLen > 0 && n >= this.lastLen && n <= this.lastLen + 1;

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

@@ -46,6 +46,8 @@ export function buildLiveEngine(env, opts) {
     let newpairs = null;
     if (!opts.noNewpairs) {
         newpairs = new NewPairsLive(feed.dl, {});
+        // 0.1.5 dev history: keep the creator of every new pair in the recorder's creator index.
+        newpairs.onCreator = (mint, creator, source, createdAt) => { recorder.recordCreator(mint, creator, source, undefined, createdAt); };
         const client = new PumpPortalClient({ health: feed.dl.health, clock: feed.dl.clock, onEvent: (ev) => newpairs.handleEvent(ev), onStatus: () => { } });
         newpairs.attach(client, 'live');
         newpairs.start();

package/dist/packages/cli/src/rules.js

@@ -1,3 +1,4 @@
+import { devBookOf } from "./live/dev-history.js";
 import { RulesEngine, ruleToJson, ruleToText, slug, applyAndJournal, describeActions, } from '../../custom/src/index.js';
 import { alertToDelivery, proposalToDelivery } from "./alerts/format.js";
 export const RULE_INPUT_MAX = 400;
@@ -66,11 +67,14 @@ export function ruleRowsOf(state) {
         return c ? c.pct : null;
     };
     const openMint = state.live?.token?.view.mint ?? null;
+    // 0.1.5 dev history: the creator's recorded rugs as the `devrugs` field (local recorder only; null = unknown).
+    const book = devBookOf(state);
+    const devRugsOf = (mint) => book ? book.rugsFor(mint) : null;
     for (const r of state.screener.rows) {
         if (!r.mint || r.skeleton || seen.has(r.mint))
             continue;
         seen.add(r.mint);
-        const row = Object.assign(Object.create(null), r, { cluster: clusterOf(r.mint), larp: larpGrade(state.larpByMint?.get(r.mint)?.verdict) });
+        const row = Object.assign(Object.create(null), r, { cluster: clusterOf(r.mint), larp: larpGrade(state.larpByMint?.get(r.mint)?.verdict), devRugs: devRugsOf(r.mint) });
         if (r.mint === openMint)
             overlaySignalFields(row, state, r.mint);
         out.push(row);
@@ -81,12 +85,31 @@ export function ruleRowsOf(state) {
         const row = Object.assign(Object.create(null), {
             mint: v.mint, symbol: v.symbol, price: v.price, mcap: v.mcap, fdv: v.fdv, liq: v.liq, vol24: v.vol24,
             holders: v.holders, org: v.org, top10: v.top10, dev: v.dev, lpLocked: v.lpLocked,
-            cluster: clusterOf(v.mint), larp: larpGrade(state.larpByMint?.get(v.mint)?.verdict),
+            cluster: clusterOf(v.mint), larp: larpGrade(state.larpByMint?.get(v.mint)?.verdict), devRugs: devRugsOf(v.mint),
             ageMin: v.ageMin, chg: v.chg, launchpad: v.launchpad, flags: v.flags, verified: v.verified, sus: v.sus,
         });
         overlaySignalFields(row, state, v.mint);
         out.push(row);
     }
+    // 0.1.5 dev history: a brand-new pair (PumpPortal / RugCheck) whose creator has a labelled record becomes a rule
+    // row too, so `devrugs >= N scope newpairs` can alert on a new coin from a wallet that rugged before. Only pairs
+    // with a known record are added (no flood of unknowns); every other field is what the new-pairs feed knows.
+    const np = state.live?.newpairs;
+    if (book && np) {
+        const now = Date.now();
+        for (const p of np.rows.values()) {
+            if (seen.has(p.mint) || !p.creator)
+                continue;
+            const devRugs = devRugsOf(p.mint);
+            if (devRugs === null)
+                continue;
+            seen.add(p.mint);
+            out.push(Object.assign(Object.create(null), {
+                mint: p.mint, symbol: p.symbol, mcap: p.mcap, liq: p.liq, holders: p.holders, launchpad: p.launchpad,
+                ageMin: p.createdAt ? Math.max(0, (now - p.createdAt) / 60_000) : null, bonding: p.bonding, devRugs,
+            }));
+        }
+    }
     return out;
 }
 /** Overlay the live-signals engine's latest values (non-null wins) onto a rule row (task-1404). */

package/dist/packages/cli/src/scan/ui.js

@@ -11,8 +11,14 @@ export const SCAN_TICK_MS = 2_000;
 export const SCAN_RECOMPUTE_MS = 10_000;
 /** The analyst UI actions a scan session may request: NONE (observe-only). */
 export const SCAN_ACTION_TYPES = Object.freeze([]);
+/** task-1473: append one line to the scan's session log (the analyst panel's brain view shows it). */
+export function scanLog(scan, t, kind, symbol, text) {
+    scan.log.push({ t, kind, symbol: cleanText(symbol, 12), text });
+    if (scan.log.length > 40)
+        scan.log.splice(0, scan.log.length - 40);
+}
 export function makeScanUi(cfg = {}) {
-    return { engine: new ScanEngine(cfg), sig: '', lastTickAt: 0, lastComputeAt: 0, session: null, blocked: [], returnTo: null };
+    return { engine: new ScanEngine(cfg), sig: '', lastTickAt: 0, lastComputeAt: 0, session: null, blocked: [], returnTo: null, log: [] };
 }
 export const MODE_LABEL = { off: 'OFF', scanning: 'SCANNING', locked: 'LOCKED', paused: 'PAUSED' };
 const SHORT = { vol: 'vol', flow: 'flow', fresh: 'fresh', breakout: 'brk', liq: 'liq', holders: 'hold' };