dexterm-cli 0.1.3 → 0.1.5

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

@@ -0,0 +1,255 @@
+// `dexterm` TUI — follow an agent that is driving over MCP (task-1421, "see what your agent is doing").
+//
+// The running terminal can WATCH and visibly FOLLOW an agent connected through `dexterm mcp` (Claude Code,
+// Cursor, Codex, Claude Desktop, …). That MCP server is a separate process the external client spawned, so
+// the app cannot set its env; instead this session, while it is open, writes the ~/.dexterm rendezvous the
+// server reads (packages/mcp spectator-sink) and tails the JSONL channel the server appends to. Each record
+// is folded into a SpectatorHub → a FollowController (the AGENT ACTIVITY panel + a SCREEN model) and, for
+// navigation calls, moved into the REAL terminal through the caller's onNav hook (open a token, switch
+// screen/feed/filter, highlight). Owner's own machine → follow mode is unredacted; the optional read-only
+// stream (SpectatorServer) redacts every copy that leaves the hub, exactly as in task-1406.
+//
+// It adds NO power. A record only DESCRIBES a read/navigation call the gate already allowed; there is no
+// inbound path from here to anything that can arm, sign, confirm, send or raise a cap. "pause / take over /
+// 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 { dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { SpectatorHub, FollowController, SpectatorServer, } from '../../agents/src/index.js';
+import { rendezvousPath, writeFollowScreen, clearFollowScreen } from '../../mcp/src/index.js';
+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')
+        return `agent ${agent}: opened${coin}`;
+    if (nav.screen === 'ticket')
+        return `agent ${agent}: opened the ${nav.side ?? ''} ticket${coin}`;
+    if (nav.screen === 'watchlist')
+        return `agent ${agent}: watchlisted${coin}`;
+    if (nav.feed)
+        return `agent ${agent}: switched the feed to ${nav.feed}`;
+    if (nav.filter)
+        return `agent ${agent}: filtered ${nav.filter}`;
+    if (nav.highlight)
+        return `agent ${agent}: highlighted ${nav.highlight.length > 10 ? nav.highlight.slice(0, 4) + '…' + nav.highlight.slice(-4) : nav.highlight}`;
+    if (nav.screen)
+        return `agent ${agent}: switched to ${nav.screen}`;
+    return `agent ${agent}: navigated`;
+}
+/**
+ * A follow session for one running terminal. Call start() to arm the rendezvous and begin tailing, pump()
+ * to process new records (the timer does this for you), the controls to pause/take-over/kill, userKey() when
+ * the human presses any key, and stop() to tear everything down. Never throws into the key loop.
+ */
+export class McpFollowSession {
+    hub;
+    follow;
+    opts;
+    rvPath;
+    channelPath;
+    token;
+    agentLabel;
+    currentAgent;
+    offset = 0;
+    timer = null;
+    stream = null;
+    armed = false;
+    paused = false;
+    lastSnapshot = 0;
+    constructor(opts) {
+        this.opts = opts;
+        this.agentLabel = opts.agentLabel || 'mcp-agent';
+        this.currentAgent = this.agentLabel;
+        this.rvPath = rendezvousPath(opts.env);
+        this.channelPath = this.rvPath.replace(/\.json$/, '.jsonl');
+        this.token = randomBytes(24).toString('hex');
+        this.hub = new SpectatorHub({ cap: Math.max(1, opts.activityCap ?? 200) });
+        const controls = {
+            pauseAgent: () => true,
+            resumeAgent: () => { this.rearm(); return true; },
+            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));
+    }
+    /** Arm the rendezvous (so a `dexterm mcp` server starts emitting) and begin tailing. Idempotent. */
+    async start() {
+        this.rearm();
+        if (this.opts.stream) {
+            try {
+                this.stream = new SpectatorServer({ hub: this.hub, env: this.opts.env });
+                await this.stream.start();
+            }
+            catch {
+                this.stream = null;
+            }
+        }
+        if (!this.timer) {
+            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 {
+            mkdirSync(dirname(this.rvPath), { recursive: true });
+            if (!this.armed) {
+                writeFileSync(this.channelPath, '', { mode: 0o600 });
+                this.offset = 0;
+            }
+            writeFileSync(this.rvPath, JSON.stringify({ file: this.channelPath, token: this.token, agent: this.agentLabel }) + '\n', { mode: 0o600 });
+            this.armed = true;
+        }
+        catch { /* best-effort local channel */ }
+    }
+    /** Remove the rendezvous so the server stops emitting (the external agent keeps running; we stop seeing it). */
+    disarm() {
+        try {
+            // 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) {
+                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() {
+        let text;
+        try {
+            const st = statSync(this.channelPath);
+            if (st.size <= this.offset) {
+                if (st.size < this.offset)
+                    this.offset = 0;
+                else
+                    return;
+            }
+            text = readFileSync(this.channelPath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        const slice = text.slice(this.offset);
+        const nl = slice.lastIndexOf('\n');
+        if (nl < 0)
+            return; // no complete line yet
+        this.offset += nl + 1;
+        for (const line of slice.slice(0, nl).split('\n')) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            let rec;
+            try {
+                rec = JSON.parse(t);
+            }
+            catch {
+                continue;
+            }
+            this.ingest(rec);
+        }
+    }
+    /** Fold one record: verify its token, strip it, emit into the hub, and move the terminal for a nav call. */
+    ingest(rec) {
+        if (typeof rec.phase !== 'string')
+            return;
+        // Only accept records written by the server we handed our token to (local 0600 file; defence in depth).
+        if (rec.token !== this.token)
+            return;
+        this.currentAgent = typeof rec.agent === 'string' && rec.agent ? rec.agent : this.agentLabel;
+        // The token NEVER enters the hub / activity / stream — fold only the observable fields.
+        const ev = this.hub.emit({
+            phase: rec.phase,
+            agent: this.currentAgent,
+            transport: 'mcp',
+            tool: rec.tool ?? null,
+            summary: rec.summary,
+            ms: rec.ms ?? null,
+            dataAgeSec: rec.dataAgeSec ?? null,
+            nav: rec.nav ?? null,
+            ok: rec.ok ?? true,
+            t: typeof rec.t === 'number' ? rec.t : undefined,
+        });
+        // Move the real terminal ONLY while the agent has control (a user keypress / take-over / kill flips this).
+        if (ev.phase === 'nav' && ev.ok !== false && ev.nav && this.canFollow()) {
+            const label = navLabel(this.currentAgent, ev.nav);
+            try {
+                this.opts.onNav?.(ev.nav, label);
+            }
+            catch { /* a bad hook never breaks the tail */ }
+            try {
+                this.opts.onStatus?.(label);
+            }
+            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?.();
+        }
+        catch { /* ignore */ }
+    }
+    /** True when the terminal should mirror the agent: the agent still has control and is active. */
+    canFollow() {
+        if (this.follow.controlState !== 'agent')
+            return false;
+        const st = this.follow.view().agents.find((a) => a.name === this.currentAgent);
+        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.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) { 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(); }
+    get controlState() { return this.follow.controlState; }
+    get isPaused() { return this.paused; }
+    get screenModel() { return this.follow.screenModel; }
+    get streamPort() { return this.stream?.port ?? 0; }
+    view() { return this.follow.view(); }
+    /** Tear down: stop the timer, remove the rendezvous, close the stream. Safe to call more than once. */
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.disarm();
+        if (this.stream) {
+            try {
+                await this.stream.close();
+            }
+            catch { /* ignore */ }
+            this.stream = null;
+        }
+    }
+}

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/screens/analyst-session.js

@@ -18,9 +18,11 @@ export function renderAnalystSession(c, x, y, w, h, s, opts) {
     const bc = mix(t.border, t.ai, 0.55);
     // 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;
-    const caption = (opts.title ?? '✦ ANALYST · claude').length + full.length + 10 <= w ? full : full.split(' · ').slice(0, 3).join(' · ');
+    // 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 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: opts.title ?? '✦ ANALYST · claude', titleFg: t.ai, caption, captionFg: capFg, border: bc });
+    const box = c.box(x, y, w, h, { title, titleFg: t.ai, caption, captionFg: capFg, border: bc });
     const bg = box.bg;
     const inner = box.w - 2;
     const frame = opts.frame;
@@ -47,7 +49,7 @@ export function renderAnalystSession(c, x, y, w, h, s, opts) {
     const drawTail = () => drawInput(c, box, bc, inputY, opts, s);
     // earlier exchanges on this warm session (compact marker; the current turn is drawn in full below)
     if (s.history.length && cy < inputY - 1) {
-        c.text(box.x + 1, cy, `⟲ ${s.history.length} earlier ${s.history.length === 1 ? 'exchange' : 'exchanges'} · one warm claude session`, { fg: t.dim, bg, i: true }, inner - 1);
+        c.text(box.x + 1, cy, `⟲ ${s.history.length} earlier ${s.history.length === 1 ? 'exchange' : 'exchanges'} · one warm ${s.engine} session`, { fg: t.dim, bg, i: true }, inner - 1);
         cy += 1;
         const last = s.history[s.history.length - 1];
         const prev = last.error ? `last: ${last.error}` : last.verdict ? `last: ${last.verdict}` : last.summary[0] ? `last: ${last.summary[0]}` : '';

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

@@ -42,7 +42,8 @@ export function renderAnalyst(c, state) {
     // next to live data — in live mode the empty tab says how to start a real conversation instead.
     if (state.screener.source !== 'fixtures') {
         const live = state.aiFocused === true;
-        const b = c.box(0, top, chatW, bottom - top, { title: '✦ ANALYST · claude', titleFg: t.ai, caption: 'read-only · local claude CLI · on demand', captionFg: t.dim, border: bc });
+        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 bbg = b.bg;
         const bin = b.w - 2;
         let by = b.y + 1;
@@ -54,7 +55,7 @@ export function renderAnalyst(c, state) {
         } };
         say2('No conversation yet.');
         by += 1;
-        say2("Press  i  to ask claude about the market, a token, or your watchlist. It can read the live screener, a token's holders / tape / RugCheck, and your watchlist — read-only, never trades.");
+        say2(`Press  i  to ask ${eng} about the market, a token, or your watchlist. It can read the live screener, a token's holders / tape / RugCheck, and your watchlist — read-only, never trades.`);
         const iy = b.y + b.h - 2;
         c.hline(b.x, iy - 1, b.w, { fg: bc, bg: bbg, soft: true });
         c.put(b.x, iy - 1, '├', { fg: bc, bg: bbg, soft: true });
@@ -64,7 +65,7 @@ export function renderAnalyst(c, state) {
         if (typed)
             c.text(b.x + 2, iy, typed + (live ? '█' : ''), { fg: t.text, bg: bbg }, bin - 2);
         else
-            c.text(b.x + 2, iy, live ? '█ type your question…  ⏎ send · esc blur' : 'press i to ask claude · ⏎ to focus', { fg: t.dim, bg: bbg, i: true }, bin - 2);
+            c.text(b.x + 2, iy, live ? '█ type your question…  ⏎ send · esc blur' : `press i to ask ${eng} · ⏎ to focus`, { fg: t.dim, bg: bbg, i: true }, bin - 2);
         if (railW)
             renderCoinList(c, chatW, top, railW, bottom - top, state);
         footer(c, analystFooter(state, live), state.theme.name, isCalm(state.vfx));

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

@@ -8,6 +8,7 @@
 // Replay is deterministic and offline. The live stream itself is started by `dexterm agent serve --spectate`;
 // it is read-only, loopback-only and token-gated, and redacts wallet addresses/keys (see SPECTATOR.md).
 import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { FollowController, loadSpectatorRecording } from '../../agents/src/index.js';
 function flag(rest, name) { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; }
@@ -15,7 +16,18 @@ function has(rest, name) { return rest.includes(name); }
 const USAGE = `dexterm spectate <command>
   --replay FILE [--json]   replay a saved session (fold agent actions into the screen + activity panel)
   --info [--json]          show the live stream endpoint from ~/.dexterm/spectator.json (if streaming)
-read-only · redacts wallet addresses/keys · the live stream is started by \`dexterm agent serve --spectate\``;
+read-only · redacts wallet addresses/keys · the live stream is started by \`dexterm agent serve --spectate\`
+or by a running app in follow mode (\`dexterm --spectate-mcp\`, for an agent connected over MCP)
+Full docs: https://dexterm.xyz/docs/spectator/`;
+/**
+ * Where `agent serve --spectate` writes its discovery file: the same rule as the writer (@dexterm/agents
+ * `dextermHome`), so a blank DEXTERM_HOME falls back and a missing HOME (Windows) does not turn into a
+ * relative `.dexterm` under the current directory.
+ */
+export function spectatorInfoPath(env, home = homedir()) {
+    const dir = env.DEXTERM_HOME && env.DEXTERM_HOME.trim() ? env.DEXTERM_HOME : join(home, '.dexterm');
+    return join(dir, 'spectator.json');
+}
 function ago(t) { const s = Math.max(0, Math.round((Date.now() - t) / 1000)); return s < 60 ? `${s}s` : s < 3600 ? `${Math.floor(s / 60)}m` : `${Math.floor(s / 3600)}h`; }
 function age(s) { if (s == null)
     return ''; return s < 60 ? ` · ${Math.round(s)}s old` : s < 3600 ? ` · ${Math.floor(s / 60)}m old` : ` · ${Math.floor(s / 3600)}h old`; }
@@ -75,8 +87,7 @@ export async function runSpectate(rest, io) {
         return 0;
     }
     if (has(rest, '--info')) {
-        const home = io.env.DEXTERM_HOME || join(io.env.HOME || '', '.dexterm');
-        const path = join(home, 'spectator.json');
+        const path = spectatorInfoPath(io.env);
         let info;
         try {
             info = JSON.parse(readFileSync(path, 'utf8'));

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

@@ -1,3 +1,3 @@
 // The one place the app's version lives (task-1397). --version, the help banner and `dexterm update` read it;
 // cli.test.ts keeps it equal to packages/cli/package.json (release.yml refuses a tag that differs).
-export const VERSION = '0.1.3';
+export const VERSION = '0.1.5';

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

@@ -52,9 +52,15 @@ function printStatus(io, store, now) {
     else {
         io.stdout.write(`login: ${meta.user ? `@${meta.user.username} (id ${meta.user.id})` : 'logged in (handle unknown)'} · scopes ${meta.scopes.join(' ') || '—'} · access token ${meta.expiresAt !== null ? (meta.expiresAt > now ? `valid ${fmtIn(meta.expiresAt - now)}` : 'expired (refreshes on next use)') : '?'} · refresh ${meta.hasRefresh ? 'yes' : 'no (login again)'}\n`);
     }
-    io.stdout.write(`files: ${store.dir} (mode ${oct(modes.dir)}) · tokens.json ${modes.tokens === null ? 'absent' : `mode ${oct(modes.tokens)}`} · client-id ${modes.clientId === null ? 'absent' : `mode ${oct(modes.clientId)}`}\n`);
-    if ((modes.tokens !== null && modes.tokens !== 0o600) || (modes.dir !== null && modes.dir !== 0o700))
-        io.stderr.write('⚠ permissions are looser than 0600/0700; dexterm will tighten them on the next write (or chmod them now)\n');
+    if (process.platform === 'win32') {
+        io.stdout.write(`files: ${store.dir} · tokens.json ${modes.tokens === null ? 'absent' : 'present'} · client-id ${modes.clientId === null ? 'absent' : 'present'} · Windows ACL isolation is not verified\n`);
+        io.stderr.write('Review the token directory Security permissions in Windows; chmod does not enforce owner-only ACLs.\n');
+    }
+    else {
+        io.stdout.write(`files: ${store.dir} (mode ${oct(modes.dir)}) · tokens.json ${modes.tokens === null ? 'absent' : `mode ${oct(modes.tokens)}`} · client-id ${modes.clientId === null ? 'absent' : `mode ${oct(modes.clientId)}`}\n`);
+        if ((modes.tokens !== null && modes.tokens !== 0o600) || (modes.dir !== null && modes.dir !== 0o700))
+            io.stderr.write('⚠ permissions are looser than 0600/0700; dexterm will tighten them on the next write (or chmod them now)\n');
+    }
     io.stdout.write(`callback: ${callbackUri()} · tokens are never printed, logged, or sent to a model · X reads are user-context only (your rate limits, your bill)\n`);
 }
 /** Run the `x` subcommand. Returns a process exit code. */
@@ -84,7 +90,7 @@ export async function runX(argv, io, over = {}) {
             io.stderr.write(`dexterm x set-client-id: ${e instanceof Error ? e.message : String(e)}\n`);
             return 2;
         }
-        io.stdout.write(`stored (${v.length} chars) at ${store.clientIdPath} (mode 600). Next: dexterm x login\n`);
+        io.stdout.write(`stored (${v.length} chars) at ${store.clientIdPath} (${process.platform === 'win32' ? 'Windows ACL isolation unverified' : 'mode 600'}). Next: dexterm x login\n`);
         return 0;
     }
     if (sub === 'login') {
@@ -101,7 +107,7 @@ export async function runX(argv, io, over = {}) {
             const res = await oauth.login({ env: io.env });
             clearTimeout(t);
             io.stdout.write(`✓ logged in${res.user ? ` as @${res.user.username}` : ''} · scopes ${res.scopes.join(' ')} · access token valid ${fmtIn(res.expiresAt - now())} · refresh ${res.hasRefresh ? 'yes' : 'no'} · browser ${Math.round(res.callbackMs / 100) / 10}s · exchange ${res.exchangeMs}ms\n`);
-            io.stdout.write(`tokens: ${store.tokensPath} (mode 600). The SOCIAL panel and TRENDING board now read X with your own limits.\n`);
+            io.stdout.write(`tokens: ${store.tokensPath} (${process.platform === 'win32' ? 'Windows ACL isolation unverified' : 'mode 600'}). The SOCIAL panel and TRENDING board now read X with your own limits.\n`);
             return 0;
         }
         catch (e) {

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

@@ -3,13 +3,13 @@ export const FIELDS = {
     vol5m: (r) => r.vol5m, vol1h: (r) => r.vol1h, vol24: (r) => r.vol24,
     holders: (r) => r.holders, org: (r) => r.org, top10: (r) => r.top10, dev: (r) => r.dev,
     lplocked: (r) => r.lpLocked, bundled: (r) => r.bundled, snipers: (r) => r.snipers,
-    cluster: (r) => r.cluster, larp: (r) => r.larp,
+    cluster: (r) => r.cluster, larp: (r) => r.larp, devrugs: (r) => r.devRugs,
     fresh: (r) => r.fresh, mintable: (r) => r.mintable, freezable: (r) => r.freezable,
     age: (r) => r.ageMin, m5: (r) => r.chg?.m5, h1: (r) => r.chg?.h1, h6: (r) => r.chg?.h6, h24: (r) => r.chg?.h24,
     buys: (r) => r.buys, sells: (r) => r.sells, bonding: (r) => r.bonding,
 };
 export const FIELD_NAMES = Object.keys(FIELDS);
-const ALIASES = { vol: 'vol24', volume: 'vol24', liquidity: 'liq', cap: 'mcap', mc: 'mcap', holder: 'holders', organic: 'org', top: 'top10', locked: 'lplocked', 'cluster%': 'cluster', clusterpct: 'cluster', freshwallets: 'fresh', mintauth: 'mintable', freezeauth: 'freezable' };
+const ALIASES = { vol: 'vol24', volume: 'vol24', liquidity: 'liq', cap: 'mcap', mc: 'mcap', holder: 'holders', organic: 'org', top: 'top10', locked: 'lplocked', 'cluster%': 'cluster', clusterpct: 'cluster', freshwallets: 'fresh', mintauth: 'mintable', freezeauth: 'freezable', devrug: 'devrugs', serialrugger: 'devrugs' };
 const OPS = { '>': (a, b) => a > b, '>=': (a, b) => a >= b, '<': (a, b) => a < b, '<=': (a, b) => a <= b, '=': (a, b) => a === b, '==': (a, b) => a === b, '!=': (a, b) => a !== b };
 const TAGS = {
     launchpad: (r, v) => (r.launchpad ?? '').toLowerCase().replace('.fun', '') === v.toLowerCase().replace('.fun', ''),

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

@@ -261,6 +261,10 @@ export const SCHEMAS = {
                     /** Reserved: the trading gate is NOT here (signer policy owns it); listed so a proposal that tries gets a precise refusal. */
                     gate: { type: 'string', enum: ['keypress'] },
                 } },
+            /** 0.1.5: which of the user's own CLIs runs the analyst. `/analyst` is user-only (DENIED_FOR_MODELS): a model never picks its own engine. */
+            analyst: { type: 'object', additional: false, props: {
+                    engine: { type: 'string', enum: ['auto', 'claude', 'codex'] },
+                } },
             /** task-1393: voice-out preferences. `/voice` is user-only (DENIED_FOR_MODELS), so only the keyboard sets it. */
             voice: { type: 'object', additional: false, props: {
                     name: { type: 'string', max: 64 },
@@ -426,7 +430,7 @@ export function applyOps(doc, ops) {
 export const DENIED_FOR_MODELS = [
     /^\/signer(\/|$)/, /^\/trading(\/|$)/, /^\/keys(\/|$)/, /^\/caps(\/|$)/, /^\/mandates?(\/|$)/, /^\/wallet(\/|$)/,
     /^\/packs(\/|$)/, /^\/plugins\/[^/]+\/(capabilities|enabled)(\/|$)/, /^\/plugins\/[^/]+$/, /^\/plugins$/,
-    /^\/jarvis\/gate(\/|$)/, /^\/jarvis\/configAssistant$/, /^\/voice(\/|$)/, /^\/alerts(\/|$)/, /^\/agents(\/|$)/, /^\/version$/,
+    /^\/jarvis\/gate(\/|$)/, /^\/jarvis\/configAssistant$/, /^\/voice(\/|$)/, /^\/analyst(\/|$)/, /^\/alerts(\/|$)/, /^\/agents(\/|$)/, /^\/version$/,
     /^\/rules\/(\d+|-)\/then\/(\d+|-)\/args\/(arm|armed|auto|autoArm|confirm|execute|sign|send)(\/|$)/,
 ];
 /** Keys a model-authored VALUE may never contain at any depth (money/secret-shaped), whatever the path. */

package/dist/packages/data/src/fixtures.js

@@ -62,21 +62,43 @@ export class FixtureStore {
     }
     save(path, note) {
         mkdirSync(dirname(path), { recursive: true });
-        const file = {
+        const raw = {
             version: 1,
             recordedAt: new Date().toISOString(),
             note: note ?? this.note,
             entries: this.list(),
         };
         if (this.streams.length)
-            file.streams = this.streams;
-        const text = JSON.stringify(file, null, 1) + '\n';
-        // Belt and braces: the key is redacted at capture time; refuse to write a file that still carries one.
-        if (containsSecret(text))
+            raw.streams = this.streams;
+        // Request URLs are redacted at capture time, but live response bodies echo third-party URLs with key-shaped
+        // params (DexScreener image URLs carry `&key=<cache id>`); refusing those threw away whole live sessions at
+        // quit (task-1443). Redact every string instead. Replay still matches: requestKey() redacts the same way.
+        const file = scrubSecrets(raw);
+        // Belt and braces: never write a file that still carries a key value (checked per string, so escaping is moot).
+        if (anyString(file, containsSecret))
             throw new Error('refusing to save a recording that contains an api-key value');
-        writeFileSync(path, text);
+        writeFileSync(path, JSON.stringify(file, null, 1) + '\n');
     }
 }
+/** A deep copy of `v` with redactSecrets() applied to every string. */
+function scrubSecrets(v) {
+    if (typeof v === 'string')
+        return redactSecrets(v);
+    if (Array.isArray(v))
+        return v.map(scrubSecrets);
+    if (v && typeof v === 'object')
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, scrubSecrets(x)]));
+    return v;
+}
+function anyString(v, pred) {
+    if (typeof v === 'string')
+        return pred(v);
+    if (Array.isArray(v))
+        return v.some((x) => anyString(x, pred));
+    if (v && typeof v === 'object')
+        return Object.values(v).some((x) => anyString(x, pred));
+    return false;
+}
 export function toEntry(req, res, recordedAt = new Date().toISOString()) {
     let body = res.body;
     let bodyIsJson = false;

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

@@ -38,6 +38,9 @@ export * from "./trade/tx-decode.js";
 export * from "./trade/sol-usd.js";
 export * from "./trade/kill-switch.js";
 export * from "./trade/token-delta.js";
+// task-1443: the paper agent desk + its rendezvous (agents paper-trade inside an armed mandate; never sign/send).
+export * from "./trade/agent/paper-desk.js";
+export * from "./trade/agent/rendezvous.js";
 export * from "./trade/signer/protocol.js";
 export * from "./trade/signer/service.js";
 export * from "./trade/signer/host.js";

package/dist/packages/data/src/sources/jupiter.js

@@ -106,6 +106,7 @@ export function normalizeJupToken(raw, fetchedAt) {
         top10Pct: numOrNull(raw.audit?.topHoldersPercentage),
         devPct: numOrNull(raw.audit?.devBalancePercentage),
         devMints: numOrNull(raw.audit?.devMints),
+        devAddress: typeof raw.dev === 'string' && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(raw.dev) ? raw.dev : null,
         lpLockedPct: null,
         rugRisks: [],
         rugScore: null,