dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/data/src/trade/plans/mandate.js

@@ -13,6 +13,15 @@ export const HARD = Object.freeze({
     tipBudgetLamports: 500_000_000, maxTipLamportsPerTx: 10_000_000, maxPriorityFeeLamportsPerTx: 10_000_000,
     ttlMs: 24 * 3600_000, maxSendsPerSec: 20,
 });
+/**
+ * task-1469: ceilings for a PAPER-ONLY mandate (`dexterm mandate draft --paper`). Only the agent paper desk reads
+ * one: the plan engine refuses to arm a plan into it, fire under it or copy-trade through it, so these numbers never
+ * reach a signer, and HARD (above) stays the ceiling of every mandate a real fill can use. Fills are still priced
+ * on a live quote, so a bigger paper size pays its real price impact.
+ */
+export const PAPER_HARD = Object.freeze({
+    ...HARD, totalUsd: 10_000, perTradeUsd: 2_000, perCoinUsd: 2_000, dailyLossUsd: 10_000, maxPriceImpactPct: 10,
+});
 /** Confirmation tiers and the multiplier they apply to a mandate's per-trade cap for plans confirmed that way. */
 export const TIERS = Object.freeze({
     'keypress': { rank: 0, perTradeMultiplier: 1.0, canArmMandate: true, canArmBatch: true },
@@ -37,6 +46,8 @@ function clamp(v, dflt, hardMax) {
 export function draftMandate(input, ctx) {
     const x = input ?? {};
     const now = ctx.clock.now();
+    const paper = x.paperOnly === true;
+    const H = paper ? PAPER_HARD : HARD;
     const actions = Array.isArray(x.actions) ? x.actions.filter((a) => a === 'buy' || a === 'sell') : ['buy', 'sell'];
     if (actions.length === 0)
         throw new MandateError('bad-request', 'at least one of buy/sell');
@@ -45,23 +56,23 @@ export function draftMandate(input, ctx) {
         id: ctx.id ?? `mandate_${now.toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
         wallet: 'fast', // the capped fast wallet; the main wallet is never named here
         budget: {
-            totalUsd: clamp(x.totalUsd, 100, HARD.totalUsd),
-            perTradeUsd: clamp(x.perTradeUsd, 20, HARD.perTradeUsd),
-            perCoinUsd: clamp(x.perCoinUsd, 40, HARD.perCoinUsd),
-            dailyLossUsd: clamp(x.dailyLossUsd, 50, HARD.dailyLossUsd),
+            totalUsd: clamp(x.totalUsd, 100, H.totalUsd),
+            perTradeUsd: clamp(x.perTradeUsd, 20, H.perTradeUsd),
+            perCoinUsd: clamp(x.perCoinUsd, 40, H.perCoinUsd),
+            dailyLossUsd: clamp(x.dailyLossUsd, 50, H.dailyLossUsd),
         },
         limits: {
-            maxArmedPlans: clamp(x.maxArmedPlans, 20, HARD.maxArmedPlans),
-            maxInFlight: clamp(x.maxInFlight, 5, HARD.maxInFlight),
-            maxOpenPositions: clamp(x.maxOpenPositions, 20, HARD.maxOpenPositions),
-            maxSlippageBps: clamp(x.maxSlippageBps, 500, HARD.maxSlippageBps),
-            maxPriceImpactPct: clamp(x.maxPriceImpactPct, 3, HARD.maxPriceImpactPct),
-            maxSendsPerSec: clamp(x.maxSendsPerSec, 5, HARD.maxSendsPerSec),
+            maxArmedPlans: clamp(x.maxArmedPlans, 20, H.maxArmedPlans),
+            maxInFlight: clamp(x.maxInFlight, 5, H.maxInFlight),
+            maxOpenPositions: clamp(x.maxOpenPositions, 20, H.maxOpenPositions),
+            maxSlippageBps: clamp(x.maxSlippageBps, 500, H.maxSlippageBps),
+            maxPriceImpactPct: clamp(x.maxPriceImpactPct, 3, H.maxPriceImpactPct),
+            maxSendsPerSec: clamp(x.maxSendsPerSec, 5, H.maxSendsPerSec),
         },
         fees: {
-            tipBudgetLamports: clamp(x.tipBudgetLamports, 50_000_000, HARD.tipBudgetLamports),
-            maxTipLamportsPerTx: clamp(x.maxTipLamportsPerTx, 1_000_000, HARD.maxTipLamportsPerTx),
-            maxPriorityFeeLamportsPerTx: clamp(x.maxPriorityFeeLamportsPerTx, 2_000_000, HARD.maxPriorityFeeLamportsPerTx),
+            tipBudgetLamports: clamp(x.tipBudgetLamports, 50_000_000, H.tipBudgetLamports),
+            maxTipLamportsPerTx: clamp(x.maxTipLamportsPerTx, 1_000_000, H.maxTipLamportsPerTx),
+            maxPriorityFeeLamportsPerTx: clamp(x.maxPriorityFeeLamportsPerTx, 2_000_000, H.maxPriorityFeeLamportsPerTx),
         },
         allowed: {
             actions,
@@ -70,8 +81,9 @@ export function draftMandate(input, ctx) {
         },
         maxTier: (typeof x.maxTier === 'string' && x.maxTier in TIERS) ? x.maxTier : 'keypress',
         createdAt: now,
-        expiresAt: now + clamp(x.ttlMs, 4 * 3600_000, HARD.ttlMs),
+        expiresAt: now + clamp(x.ttlMs, 4 * 3600_000, H.ttlMs),
         status: 'draft', armedAt: null, armedBy: null, revokedAt: null, revokedReason: null,
+        ...(paper ? { paperOnly: true } : {}),
     };
     // perTrade can never exceed total; perCoin never exceeds total.
     m.budget.perTradeUsd = Math.min(m.budget.perTradeUsd, m.budget.totalUsd);
@@ -117,7 +129,8 @@ export function revokeMandate(m, reason, ctx) {
 }
 /** Hash of the caps a gesture arms — the proof binds to these numbers, not to the mandate id alone. */
 export function capsHash(m) {
-    return createHash('sha256').update(JSON.stringify({ b: m.budget, l: m.limits, f: m.fees, a: m.allowed, t: m.maxTier, e: m.expiresAt, w: m.wallet })).digest('hex').slice(0, 16);
+    // task-1469: the paper-only flag is part of what a gesture arms; a normal mandate hashes exactly as before.
+    return createHash('sha256').update(JSON.stringify({ b: m.budget, l: m.limits, f: m.fees, a: m.allowed, t: m.maxTier, e: m.expiresAt, w: m.wallet, ...(m.paperOnly === true ? { p: 1 } : {}) })).digest('hex').slice(0, 16);
 }
 /** Alive = armed and not expired. Expiry is checked on every call, never cached. */
 export function mandateAlive(m, now) {

package/dist/packages/data/src/trade/plans/service.js

@@ -66,38 +66,14 @@ export class PlanService {
         this.gate = new ConfirmGate({ clock: this.clock, journal: this.journal, settings: this.settings, rng: opts.rng });
         this.paper = opts.executor ?? new PaperPlanExecutor({ clock: this.clock, solUsd: opts.solUsd });
         const deps = { clock: this.clock, journal: this.journal, executor: this.paper, gate: this.gate, safety: opts.safety, priceMaxAgeMs: opts.priceMaxAgeMs, debounceTicks: opts.debounceTicks };
-        // Recover from an existing journal (replay + settle in-flight) or start fresh. The fire path always starts
-        // PAPER (task-1363): live is a per-run keypress opt-in, never recovered from the journal.
+        // Recover from an existing journal (replay + settle in-flight) or start fresh. The fire path is PAPER
+        // (task-1571: there is no live executor in the build; dexterm holds no key).
         this.engine = path && existsSync(path) ? PlanEngine.recover(deps) : new PlanEngine(deps);
     }
-    /** The executor the engine fires through right now (paper by default; the live adapter after useLive). */
+    /** The executor the engine fires through (the paper executor unless a test injects one). */
     get executor() { return this.engine.executor; }
     /** 'paper' unless a live executor is installed. Surfaces that cannot prove 'paper' must render LIVE. */
     mode() { return this.engine.executor.kind === 'live' ? 'live' : 'paper'; }
-    // ── the fire path (task-1363). Switching to LIVE is a physical keypress on the plans screen (never voice,
-    // an agent, a pipe or the popup): the gesture is required here AND the signer only fills from a fast wallet
-    // that was itself created by a TTY keypress. A switch while plans are armed/filled would strand their legs on
-    // the other executor's ledger, so both directions refuse until those plans are cancelled or finished. ──
-    useLive(executor, gesture) {
-        if (gesture?.gesture !== 'keypress')
-            throw new ConfirmError('live-needs-keypress', 'switching plan fills to LIVE needs a physical keypress');
-        if (executor.kind !== 'live')
-            throw new PlanError('bad-request', 'useLive needs a live executor');
-        const open = this.engine.openPlans();
-        if (open.length)
-            throw new PolicyRefusal('open-plans', `cancel or finish ${open.length} open plan(s) before switching the fire path`);
-        this.engine.replaceExecutor(executor);
-        this.journal.append('settings.executor', { data: { kind: 'live', network: 'devnet', by: 'keypress', label: executor.describe?.() ?? 'live' } });
-    }
-    usePaper() {
-        if (this.engine.executor === this.paper)
-            return;
-        const open = this.engine.openPlans();
-        if (open.length)
-            throw new PolicyRefusal('open-plans', `cancel or finish ${open.length} open plan(s) before switching the fire path`);
-        this.engine.replaceExecutor(this.paper);
-        this.journal.append('settings.executor', { data: { kind: 'paper' } });
-    }
     // ── proposals (voice/claude/user/batch all land here; a proposal is inert until armed) ──
     propose(input, ctx) {
         return this.engine.propose(input, { supply: ctx.supply, by: ctx.by ?? 'user', ref: ctx.ref ?? null });
@@ -149,7 +125,7 @@ export class PlanService {
             return {
                 id: x.m.id, status: x.m.status, wallet: x.m.wallet, totalUsd: x.m.budget.totalUsd, perTradeUsd: x.m.budget.perTradeUsd,
                 perCoinUsd: x.m.budget.perCoinUsd, maxTier: x.m.maxTier, reservedUsd: L.reservedUsd, spentUsd: L.spentUsd,
-                realizedUsd: L.realizedUsd, lossUsd: L.lossUsd, expiresAt: x.m.expiresAt,
+                realizedUsd: L.realizedUsd, lossUsd: L.lossUsd, expiresAt: x.m.expiresAt, paperOnly: x.m.paperOnly === true,
             };
         });
     }

package/dist/packages/mcp/assets/kb/app-help/autotrade-chat.md

@@ -0,0 +1,48 @@
+---
+id: autotrade-chat
+title: Change an autotrade strategy by chat (paper)
+kind: app-help
+screen: autotrade
+feature: autotrade-chat
+tags:
+  - app-help
+  - autotrade
+  - strategy
+  - chat
+  - analyst
+  - proposal
+  - tune
+  - change
+  - diff
+  - looser
+  - less
+  - safe
+keys:
+  - a
+  - o
+actions:
+  - analyst.toggle
+  - autotrade.proposal
+tools:
+  - strategy_list
+  - strategy_get
+  - strategy_validate
+  - strategy_propose_edit
+  - strategy_propose_new
+  - strategy_backtest
+  - autotrade_status
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Ask the analyst to change one of your strategies ("make my swing exit faster"). It can only PROPOSE: the change arrives as a card on the AUTOTRADE screen (`Q`) with the field lines that change, the validation result and TIGHTER, NEUTRAL or LOOSER. `o` opens the card, `y` applies it as a new version (journaled with who proposed it), `n` dismisses it. When any risk number gets less safe (bigger size or exposure, more loss, a stop or safety gate removed) the edit is LOOSER and needs a second `y` on the less-safe popup. The mode, the book, the daily session budget and the exit-liquidity floor are yours only: the analyst cannot change them. It can backtest a proposal next to the current version on your recorded history (up to 14 days, read-only). Paper only.
+
+Keys: `a`, `o` (autotrade).

package/dist/packages/mcp/assets/kb/app-help/autotrade-parallel.md

@@ -0,0 +1,42 @@
+---
+id: autotrade-parallel
+title: Run several autotrade strategies at once on paper (dexterm autotrade run --all)
+kind: app-help
+screen: all
+feature: autotrade-parallel
+tags:
+  - app-help
+  - autotrade
+  - parallel
+  - several
+  - multiple
+  - strategies
+  - compare
+  - side
+  - forward
+  - test
+  - bankroll
+  - fleet
+  - autotrade.json
+commands:
+  - autotrade
+tools:
+  - autotrade_parallel_list
+  - autotrade_parallel_compare
+  - autotrade_parallel_start
+  - autotrade_parallel_stop
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade run --all --paper` runs every strategy listed in ~/.dexterm/autotrade/autotrade.json at the same time on one data feed, to forward-test several ideas side by side. Each entry has an `id`, a `preset` (a shipped preset or your own strategy) or an absolute `file`, a `bankroll` in USD or SOL, optional `caps` that can only tighten it, and `enabled`. Each strategy gets its own paper book, run file, loss limits and breaker, sessions and model spend budget; a breaker or a stop on one never stops another. The screener fetches once for all of them, and the `global` limits (sessions open at once, model spend and sessions per day, one check of how busy the computer is) count across all of them. `dexterm autotrade status --all` and the runner view on the AUTOTRADE screen (`Q`) compare them: P/L, win rate with the closed count, rug exits and exposure, missed runners, spend per entry. `dexterm autotrade stop|flatten|pause|resume` act on every strategy; add `--strategy ID` to act on one, and `dexterm autotrade start ID` starts a listed one that is not running. An MCP agent can list and compare them and start or stop one listed strategy, never add one or change a size or a cap. Paper only: live is refused. Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#several-strategies-at-once
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-runner.md

@@ -0,0 +1,35 @@
+---
+id: autotrade-runner
+title: The autotrade paper runner and candidate sessions (dexterm autotrade run)
+kind: app-help
+screen: all
+feature: autotrade-runner
+tags:
+  - app-help
+  - autotrade
+  - runner
+  - run
+  - candidate
+  - session
+  - sessions
+  - agent
+  - replay
+  - ledger
+  - runner.json
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade run <id|file> --paper` runs one strategy on paper, headless, one runner per machine: the screener feeds it the same live data as the app (every 10 s, candidate and held coins every 5 s), and each coin that matches gets one session on your own Claude login with the full picture first, then only what changed. Your agent answers with a typed decision (enter, wait, skip, hold, exit, tighten, reprofile); every size is clamped by your strategy and the exits run on their own. At most 2 sessions at once, $0.50 per session and the day caps in ~/.dexterm/autotrade/runner.json (which Claude account, sessions and spend per day, a usage guard). Every step goes to ~/.dexterm/autotrade/runs/<run>.jsonl, hash-chained. `--replay FILE` paces a recorded tape instead of live data; `--stub` uses a scripted agent with no Claude cost. Paper only: a run never signs or touches a wallet, and there is no `--live` (dexterm holds no key and places no live order). Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#the-runner-and-candidate-sessions
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-stop.md

@@ -0,0 +1,37 @@
+---
+id: autotrade-stop
+title: Stop, flatten or audit the autotrade paper runner (dexterm autotrade stop|flatten|audit)
+kind: app-help
+screen: all
+feature: autotrade-runner
+tags:
+  - app-help
+  - autotrade
+  - stop
+  - kill
+  - halt
+  - flatten
+  - sell
+  - pause
+  - panic
+  - audit
+  - verify
+  - ledger
+  - resume
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade stop` is a soft stop of the paper runner: no new entries, every session closed, pending orders dropped, and the mechanical exits (stops, take-profits, trails, rug exits) keep running until nothing is held; then the runner ends. `dexterm autotrade flatten` stops it and sells every paper position at its next tick (a coin that cannot sell is retried every tick); it asks for y on a real terminal, or takes --yes. On the AUTOTRADE screen (`Q`): `!` stops, `p` pauses or resumes new entries, `f` then y flattens. A stop is final for that run. `dexterm wallet panic` is the harder switch: the runner reads it every step, a new run will not start while it is on, and only `dexterm wallet resume` on a real terminal lifts it. `dexterm autotrade audit --verify` recomputes the hash chain of every run file in ~/.dexterm/autotrade/runs/ and names the first edited, missing or reordered line. Paper only; your agent cannot stop, resume or flatten anything. Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/#stopping-it
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-strategies.md

@@ -0,0 +1,35 @@
+---
+id: autotrade-strategies
+title: Autotrade strategies on paper (dexterm autotrade)
+kind: app-help
+screen: all
+feature: autotrade-strategies
+tags:
+  - app-help
+  - autotrade
+  - strategy
+  - strategies
+  - preset
+  - presets
+  - moonbag
+  - scalp
+  - swing
+  - sweep
+  - held-out
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm autotrade list|validate|new|import|remove|journal` manages strategy files in ~/.dexterm/strategies (one validated JSON file each, every change in an append-only journal); the presets scalp, swing, runner, moonbag, sample-dip-ladder and yolo (HIGH RISK, see the yolo entry) are read-only, copy one with `dexterm autotrade new <id> --from <preset>`. `dexterm autotrade backtest <id>` replays a strategy over your recorded history with modelled fills and always prints the limits of the data (`--every-candidate`, `--recall 5,10` for tail strategies); `dexterm autotrade sweep <id>` tunes on older coins and checks once on the newest 30% it never saw, with no gain wording unless both halves have 20+ trades and the held-out net is positive. Paper only: a strategy cannot hold a key, wallet or signer section, and a copy in mode live does not run (dexterm holds no key and places no live order). Not financial advice. Full docs: https://dexterm.xyz/docs/autotrade/
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/autotrade-telegram.md

@@ -0,0 +1,40 @@
+---
+id: autotrade-telegram
+title: Your own Telegram bot for the autotrade runner: notify, control, one-tap approvals (dexterm telegram)
+kind: app-help
+screen: all
+feature: autotrade-telegram
+tags:
+  - app-help
+  - telegram
+  - bot
+  - phone
+  - mobile
+  - notify
+  - notifications
+  - approve
+  - approval
+  - approvals
+  - pair
+  - pairing
+  - kill
+  - pause
+  - remote
+  - botfather
+commands:
+  - telegram
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Create a bot with @BotFather, then run `dexterm telegram setup`: paste the token at the hidden prompt (never as an argument), dexterm checks it and keeps it in your keychain (or the system keyring, or a 0600 file), then shows a 6-digit code; send `/pair <code>` to your bot from your own private chat and confirm the account it shows (@username and id) with `y` on your computer. Pairing is refused while a webhook or another program polls the bot. Only that account in that chat is answered. `dexterm autotrade run <id> --paper` then starts the bot by itself (`--no-telegram` keeps it off): entries, exits, PnL cards, halts and a daily summary reach your phone; `/status`, `/positions`, `/pause`, `/resume` (a pause only), `/kill`, `/flatten` and `/use` (each after a confirm button, `/use` only to an equal-or-tighter strategy; a change it cannot rank counts as looser) and `/approvals on` work from chat, which can make things safer and never less safe. With `entry.decide: "agent+approve"` or approvals on, every entry is a card with [Approve] [Half size] [Skip]: only a button approves, once, for that proposal, your account and your private chat; the price and your limits are checked again at the tap; no answer is a skip. Typed messages are never trades. `dexterm telegram status|test|audit --verify|revoke`. Nothing is hosted; paper only; never send keys or seed phrases in chat. Not financial advice. Full docs: https://dexterm.xyz/docs/telegram/
+
+CLI: `dexterm telegram`.

package/dist/packages/mcp/assets/kb/app-help/chart-trade-markers.md

@@ -0,0 +1,42 @@
+---
+id: chart-trade-markers
+title: See your buys and sells on the chart (B / S markers)
+kind: app-help
+screen: token
+feature: chart-trade-markers
+tags:
+  - app-help
+  - markers
+  - marker
+  - buy
+  - sell
+  - bought
+  - sold
+  - fills
+  - fill
+  - entry
+  - exit
+  - trades
+  - chart
+  - avg
+  - average
+  - paper
+  - live
+  - arrows
+commands:
+  - display
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Every fill of the open coin from your paper ledger (your own and an agent's PAPER trades) and the live ledger (confirmed real swaps) is marked on the token screen's chart and the chart popup, on every timeframe: `B` for a buy and `S` for a sell, at the fill's time and price. Hollow `△ ▽` = PAPER, solid `▲ ▼` = live, so it reads without colour too. Each partial sell gets its own marker (several in one bar show a count), a dashed `avg` line marks the average entry while the position is open, and a closed round trip gets a faint wash from entry to exit. A fill outside the candles on screen is not moved: the chart says how many are off-chart. In the popup, hover a marker for its time, price, size and ledger; `k` or the **MARKERS** button turns them off or on for both charts (saved as `display.chartMarkers`; also `dexterm display markers on|off`). Display only: no marker can arm, size, sign or confirm anything, and nothing is fetched to draw them.
+
+CLI: `dexterm display`.

package/dist/packages/mcp/assets/kb/app-help/dev-history.md

@@ -29,4 +29,4 @@ sources:
 date: 2026-10-16
 ---
 
-The token screen's ON-CHAIN panel shows the creator's recorded track record (0.1.5): `Dev rugs (recorded)` (rugs out of labelled prior launches, with the sample n), `Dev launches seen`, `Dev sold its bag` (median minutes to the dev's exit) and `Dev linked` (funder or cluster from the wallet-intel scan). It comes from dexterm's own local history recorder (keyless creator links + code-only outcome labels), so it says `unknown` when there is no record; it is a risk flag from observed history, never a certificate. Alert on it with the rule field `devrugs`, e.g. `when devrugs >= 2 then alert(warn, "new coin from a wallet that rugged before") scope newpairs`. Agents and the analyst use the `dev_history` MCP tool.
+The token screen's ON-CHAIN panel shows the creator's recorded track record (0.1.5): `Dev rugs` (rugs out of labelled prior launches, e.g. `2/3 · n=3 · rec 7d`), `Dev launches` (`n=3 · rec 2h · dev:jup`: which feed named the creator), `Dev sold bag` (median minutes to the dev's exit, `med 20m · n=3 · rec 1d`), `Dev linked` (funder or cluster from the wallet-intel scan, with the scan's age) and `Linked dev rugs` (rugs by other wallets in that cluster). Every value names its source (`rec` = the recorder, `scan` = the wallet-intel scan), its sample (n=) and the age of its newest datum. It comes from dexterm's own local history recorder (keyless creator links + code-only outcome labels), so it says `unknown` when there is no record; it is a risk flag from observed history, never a certificate. Alert on it with the rule field `devrugs`, e.g. `when devrugs >= 2 then alert(warn, "new coin from a wallet that rugged before") scope newpairs`. Agents and the analyst use the `dev_history` MCP tool.

package/dist/packages/mcp/assets/kb/app-help/larp-check.md

@@ -15,12 +15,16 @@ tags:
   - domain
   - github
   - vet
+  - score
+  - x
+  - twitter
 tools:
   - larp_check
   - get_links
   - fetch_page
   - check_domain
   - check_github
+  - check_x
 confidence: high
 owner: maintainers
 origin: app-help-generated
@@ -33,4 +37,4 @@ sources:
 date: 2026-10-16
 ---
 
-The LARP check vets whether a real product exists (website, domain age, GitHub) read-only — it is not a price call. Ask the analyst "is <coin> a larp?" (skill `larp-check`), or an agent can call the `larp_check` MCP tool. A grade is a risk flag, never a certificate; it never recommends buy/sell.
+The LARP check vets whether a real product exists (website, domain age, GitHub, the X account) read-only — it is not a price call. Ask the analyst "is <coin> a larp?" (skill `larp-check`), or an agent can call the `larp_check` MCP tool. It returns a 0-100 LARP score: the sum of named flags with their points (low under 25, medium 25-49, high 50+), plus a list of what could not be read, which widens the range instead of lowering the score. A score is a summary of flags, never a certificate; it never recommends buy/sell.

package/dist/packages/mcp/assets/kb/app-help/link-a-wallet.md

@@ -1,6 +1,6 @@
 ---
 id: link-a-wallet
-title: Link a wallet for trading (dexterm wallet)
+title: Link a wallet to show its public key (dexterm wallet)
 kind: app-help
 screen: all
 feature: trading
@@ -12,17 +12,11 @@ tags:
   - phantom
   - connect
   - pubkey
-  - caps
-  - trade
+  - panic
+  - resume
 commands:
   - wallet
 flags:
-  - --mainnet
-  - --max-usd
-  - --daily-usd
-  - --max-sol-out
-  - --max-slippage-bps
-  - --trade-rpc
   - --no-live
 confidence: high
 owner: maintainers
@@ -36,6 +30,6 @@ sources:
 date: 2026-10-16
 ---
 
-`dexterm wallet link|unlink|status` links a Phantom wallet through a loopback bridge — your keys NEVER enter dexterm, only the public key is stored — and shows the link and the signer-side trade caps. dexterm is non-custodial: it builds and simulates transactions, your own wallet signs. The signer-side caps (`--max-usd`, `--daily-usd`, `--max-sol-out`, `--max-slippage-bps`) and the RPC (`--trade-rpc`) bound every trade and live on the signer; `--mainnet` opts in to mainnet and `--no-live` keeps it paper-only. The analyst can never link, unlink, sign, arm or change a cap.
+`dexterm wallet link|unlink|status` links a Phantom wallet through a loopback bridge (Phantom signs a MESSAGE, never a transaction): your keys NEVER enter dexterm, only the public key is stored, for display. dexterm holds no key and never signs or sends a transaction; trading in dexterm is paper, and live trading happens in the Telegram trading bot of your choice. `dexterm wallet panic` halts autotrade runs and the paper agent desk at once; only `dexterm wallet resume`, a keypress on a real terminal, clears it. `--no-live` (0.1.6) is accepted and changes nothing. The analyst can never link, unlink or resume.
 
 CLI: `dexterm wallet`.

package/dist/packages/mcp/assets/kb/app-help/live-trading.md

@@ -0,0 +1,38 @@
+---
+id: live-trading
+title: Live trading: dexterm holds no key; a Telegram trading bot of your choice trades
+kind: app-help
+screen: all
+feature: live-trading
+tags:
+  - app-help
+  - live
+  - trading
+  - real
+  - money
+  - telegram
+  - bot
+  - key
+  - wallet
+  - custody
+  - signer
+  - mainnet
+commands:
+  - telegram
+  - wallet
+  - live
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+dexterm never holds a key and never signs or sends a transaction: there is no trading wallet, no signer and no live order in dexterm. Live trading happens in a Telegram trading bot of your choice, which holds its own wallet; you act in that bot. dexterm's part is the Telegram connector to your OWN bot (`dexterm telegram setup`): alerts, signals and run control for your paper runs. dexterm 0.1.7 does not place orders in a trading bot for you. Paper trading (the ticket, paper accounts, paper autotrade) is local. `dexterm wallet link` keeps a Phantom public key for display only. Not financial advice. Full docs: https://dexterm.xyz/docs/live-trading/
+
+CLI: `dexterm telegram`, `dexterm wallet`, `dexterm live`.

package/dist/packages/mcp/assets/kb/app-help/live-yolo.md

@@ -0,0 +1,34 @@
+---
+id: live-yolo
+title: The full-port yolo strategy on paper: replay and a paper run (HIGH RISK)
+kind: app-help
+screen: all
+feature: yolo-preset
+tags:
+  - app-help
+  - yolo
+  - full
+  - port
+  - all-in
+  - high
+  - risk
+  - preset
+  - replay
+  - paper
+commands:
+  - autotrade
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+HIGH RISK, PAPER only; not financial advice. The `yolo` preset enters one young pair at a time on an early 5-minute push after the holder-safety gates (LP burned or locked, no mint or freeze authority, a LARP score of 49 or less checked live before a coin becomes a candidate, liquidity of $25K or more), takes the cost back at about 2x, lets the rest ride on a loose 50% trail, exits at once on a liquidity pull, a dev sell or dead volume, has a -50% stop and a 45-minute time stop, and never buys the same coin twice. On paper it caps an entry at 25% like every strategy. `dexterm autotrade yolo-replay yolo` measures every entry at full port over your recorded history (rugs, the loss spread, how often it zeroed the wallet); `dexterm autotrade run yolo --paper` runs it on paper (`--replay builtin:yolo-rehearsal --stub` for a short fixture run; next to other strategies, or on a shared paper account, through `autotrade.json` and `dexterm autotrade run --all --paper`). Stop: `dexterm autotrade stop`, /kill in Telegram, Ctrl-C. dexterm places no live order. Full docs: https://dexterm.xyz/docs/yolo/
+
+CLI: `dexterm autotrade`.

package/dist/packages/mcp/assets/kb/app-help/order-plans.md

@@ -28,6 +28,6 @@ sources:
 date: 2026-10-16
 ---
 
-`dexterm plan list|add|remove|arm|disarm` sets conditional order plans (e.g. take-profit / stop levels). Voice and agents can only PROPOSE a plan; ARMING one needs your physical keypress, and the caps and panic-stop stay signer-side. Nothing here lets a model sign or raise a cap.
+`dexterm plan list|add|remove|arm|disarm` sets conditional order plans (e.g. take-profit / stop levels). Voice and agents can only PROPOSE a plan; ARMING one needs your physical keypress, and plans fill on PAPER (dexterm places no live order). Nothing here lets a model sign or raise a cap.
 
 CLI: `dexterm plan`.

package/dist/packages/mcp/assets/kb/app-help/price-or-marketcap.md

@@ -1,6 +1,6 @@
 ---
 id: price-or-marketcap
-title: Show price or market cap
+title: Market cap or price (market cap is the default)
 kind: app-help
 screen: all
 feature: price-display-mode
@@ -13,6 +13,7 @@ tags:
   - display
   - usd
   - cap
+  - basis
 keys:
   - $
 actions:
@@ -21,6 +22,8 @@ commands:
   - display
 flags:
   - --price-mode
+  - --price
+  - --mcap
 confidence: high
 owner: maintainers
 origin: app-help-generated
@@ -33,6 +36,6 @@ sources:
 date: 2026-10-16
 ---
 
-Press `$` to flip every price between USD price and MARKET CAP (screener, watchlist, new pairs, token, both charts, order-plan levels). Saved as `display.priceMode`; also `dexterm display price|mcap` or `--price-mode`. A coin with no known supply stays on price and says so. The analyst can set this for you.
+Market cap is the default basis: every screen, the CLI text, the chat assistant and the autotrade agents show and talk about a coin in market cap (entered at $69.7K, exited at $264.9K, 3.8x). Press `$` (or type `/display price` in the chat box, `/display mcap` to go back) to switch to USD price and back. Saved as `display.priceMode`; also `dexterm display mcap|price`. For one run: `--price` / `--mcap` on any command, `--price-mode`, or `DEXTERM_PRICE_BASIS=price`. Market cap = price × a known supply (the source's cap ÷ price, recorded FDV ÷ price, or pump.fun's 1B); a coin with no known supply shows its price marked ᵖ and says so. JSON keeps both `price` and `mcap`. The charts have their own axis setting (`A`). The analyst can propose this for you.
 
 Keys: `$`. CLI: `dexterm display`.

package/dist/packages/mcp/assets/kb/app-help/scan-mode.md

@@ -32,6 +32,6 @@ sources:
 date: 2026-10-16
 ---
 
-Scan mode is an observe-only AI watcher (off by default, zero extra requests). Toggle it with `Z` (or `/scan on|off` on the screener line, or `--scan` at launch); `R` resumes a paused scan. It can only surface findings, never take a UI action or trade (structurally observe-only). The analyst can turn it on or off for you.
+Scan mode is an observe-only AI watcher (off by default, zero extra requests). Toggle it with `Z` (or `/scan on|off` on the screener line, or `--scan` at launch); `R` resumes a paused scan. It can only surface findings, never take a UI action or trade (structurally observe-only). While it is on, the token screen's analyst panel shows its brain view: the scan log (locks, refreshes, releases, blocked actions) with the read streaming under it, the vetting checklist and the data strip. While it runs and you hold a paper or live position, a PnL chip shows it on the band under the header of every screen and on the chart popup; display only. The analyst can turn it on or off for you.
 
 Keys: `Z`, `R`.

package/dist/packages/mcp/assets/kb/app-help/screen-analyst.md

@@ -67,6 +67,7 @@ keys:
   - ctrl+w o
   - ctrl+w d
   - ctrl+r
+  - Q
 actions:
   - quit
   - screen.screener
@@ -113,6 +114,7 @@ actions:
   - workspace.popups
   - workspace.default
   - screen.rules
+  - screen.autotrade
 tools:
   - get_dossier
   - kb_search
@@ -176,6 +178,7 @@ Keys on this screen:
   `^W o` — open workspace popups
   `^W d` — default workspace
   `^R` — rules
+  `Q` — autotrade (paper)
   `type` — ask a follow-up · ⏎ send · esc clear/back
   `c` — calm mode (effects off)
   `?` — this help