dexterm-cli 0.1.6 → 0.2.0

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

@@ -1,15 +1,36 @@
 // @dexterm/agents — a small, total JSON-schema checker for tool arguments (task-1345).
 //
 // Covers the subset the dexterm tool table uses: object/string/integer/number/boolean, enum, minimum,
-// maximum, maxLength, required, additionalProperties:false, nested objects. Anything the schema does
+// maximum, maxLength, required, additionalProperties:false, nested objects, and (task-1507) `free` JSON values. Anything the schema does
 // not mention is an error (schemas are closed: `additionalProperties` defaults to false for agent
 // calls even when a schema omits it). Pure and never throws.
+const FREE_DEPTH = 12;
+function freeError(v, path, depth = 0) {
+    if (depth > FREE_DEPTH)
+        return `${path}: too deeply nested`;
+    if (typeof v === 'string')
+        return /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/.test(v) ? `${path}: control characters are not allowed` : null;
+    if (v === null || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v)))
+        return null;
+    if (typeof v !== 'object')
+        return `${path}: not a JSON value`;
+    for (const [k, x] of Array.isArray(v) ? v.entries() : Object.entries(v)) {
+        if (k === '__proto__' || k === 'constructor' || k === 'prototype')
+            return `${path}.${String(k)}: not allowed`;
+        const err = freeError(x, `${path}.${String(k)}`, depth + 1);
+        if (err)
+            return err;
+    }
+    return null;
+}
 const MAX_STRING = 2000;
 const MAX_DEPTH = 6;
 const MAX_KEYS = 32;
 export function validateArgs(schema, value, path = 'args', depth = 0) {
     if (depth > MAX_DEPTH)
         return `${path}: too deeply nested`;
+    if (schema?.free)
+        return value === undefined ? null : freeError(value, path);
     if (!schema)
         return value === undefined || (typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length === 0) ? null : `${path}: this tool takes no arguments`;
     const t = schema.type ?? (schema.properties ? 'object' : undefined);

package/dist/packages/agents/src/spectator.js

@@ -20,7 +20,9 @@ const ADDR_RE = new RegExp(`${BASE58}{32,44}`, 'g');
 const LONG_B58_RE = new RegExp(`${BASE58}{45,}`, 'g');
 /** A hex run of ≥64 chars is a 32-byte key / signature. */
 const HEX_KEY_RE = /\b[0-9a-fA-F]{64,}\b/g;
-export const SENSITIVE_KEY_RE = /(secret|private|privkey|mnemonic|seed|passphrase|password|signature|sig|apikey|api[_-]?key|keypair|token)/i;
+// task-1645: real mode's trade-fire signals and receipts stay out of shared views (`sig` already covers signal,
+// signalId and txSig; receipt, nonce and trade_fire are added).
+export const SENSITIVE_KEY_RE = /(secret|private|privkey|mnemonic|seed|passphrase|password|signature|sig|apikey|api[_-]?key|keypair|token|receipt|nonce|trade[_-]?fire)/i;
 /** Mask one address the way the product's shortAddr does (head4…tail4). */
 export function maskAddress(s) {
     return s.length <= 10 ? s : `${s.slice(0, 4)}…${s.slice(-4)}`;

package/dist/packages/agents/src/story.js

@@ -8,6 +8,7 @@
 // terminal HUD, the popup and tests all see the same story. Every number is copied from an app-computed detail
 // (SpectatorDetail) or from the app's own mark price; agent text only ever reaches the thought ribbon, scrubbed.
 // Like follow.ts it has no action path: it cannot arm, sign, size, confirm or raise a cap.
+import { fmtCap, knownSupply } from '../../data/src/basis.js';
 import { maskAddress } from "./spectator.js";
 /** The rail, in the order a trade moves through it (idle is not on the rail). */
 export const STORY_RAIL = ['scanning', 'vetting', 'sizing', 'executing', 'holding', 'exiting'];
@@ -291,7 +292,7 @@ export class AgentStory {
                 a.spentSol = buys.reduce((s, x) => s + Math.abs(x.sol), 0);
                 if (a.stage !== 'open') {
                     this.score.entries += 1;
-                    this.decide(t, 'enter', a.symbol, `entered · ${Math.abs(f.sol).toFixed(4)} SOL${a.sizeUsd != null ? ` ($${a.sizeUsd.toFixed(2)})` : ''}${f.priceUsd != null ? ` @ $${fmtPx(f.priceUsd)}` : ''}`);
+                    this.decide(t, 'enter', a.symbol, `entered · ${Math.abs(f.sol).toFixed(4)} SOL${a.sizeUsd != null ? ` ($${a.sizeUsd.toFixed(2)})` : ''}${f.priceUsd != null ? ` @ ${fillAt(f.mint, f.priceUsd)}` : ''}`);
                 }
                 a.stage = 'open';
                 a.filledAt = a.filledAt ?? t;
@@ -486,7 +487,7 @@ function narrate(tool, d, ev, names, refused) {
     if (d.fill) {
         const f = d.fill;
         if (f.side === 'buy')
-            return `PAPER FILL · ${Math.abs(f.sol).toFixed(4)} SOL → ${fmtQty(f.qty)} ${sym(f.mint)}${f.priceUsd != null ? ` @ $${fmtPx(f.priceUsd)}` : ''}`;
+            return `PAPER FILL · ${Math.abs(f.sol).toFixed(4)} SOL → ${fmtQty(f.qty)} ${sym(f.mint)}${f.priceUsd != null ? ` @ ${fillAt(f.mint, f.priceUsd)}` : ''}`;
         return `PAPER SELL · ${fmtQty(f.qty)} ${sym(f.mint)} → ${fmtSol(f.sol)}${f.realizedSol != null ? ` · realized ${fmtSol(f.realizedSol)}` : ''}`;
     }
     if (d.ticket) {
@@ -511,6 +512,14 @@ export function fmtQty(n) {
         return `${(n / 1e3).toFixed(1)}K`;
     return n.toFixed(a >= 10 ? 0 : 2);
 }
+/**
+ * task-1537: a fill level in narration: the market cap it filled at when the supply is known without a guess (pump.fun's
+ * fixed 1B), the price beside it; else the price alone. Both numbers, so either basis reads it.
+ */
+export function fillAt(mint, priceUsd) {
+    const sup = knownSupply({ mint });
+    return sup ? `${fmtCap(priceUsd * sup.tokens)} mcap ($${fmtPx(priceUsd)})` : `$${fmtPx(priceUsd)}`;
+}
 /** A price in USD with enough significant digits for a micro-cap (0.0000531). */
 export function fmtPx(n) {
     if (!Number.isFinite(n))

package/dist/packages/agents/src/tiers.js

@@ -6,7 +6,7 @@
 //
 //   observe   read tools and live streams
 //   annotate  + non-financial UI navigation on the user's screen, agent-owned notes/tags on coins
-//   propose   + proposals: alerts, order plans, watchlist adds — they appear labelled with the agent and
+//   propose   + proposals: alerts, order plans, watchlist adds, strategy edits — they appear labelled with the agent and
 //               need the user's keypress; nothing an agent proposes is ever applied by itself
 //
 // NEVER, for any agent at any tier (ROADMAP hard rule, SPEC §6.0): arm, sign, confirm, send, raise or
@@ -57,6 +57,28 @@ export const TOOL_TIERS = Object.freeze({
     check_x: 'observe',
     agent_whoami: 'observe',
     list_proposals: 'observe',
+    // AUTOTRADE strategy reads (task-1507, paper): the strategies, a backtest on recorded history (read-only,
+    // bounded, rate-limited) and the paper runner's status
+    strategy_list: 'observe',
+    strategy_get: 'observe',
+    strategy_validate: 'observe',
+    strategy_backtest: 'observe',
+    autotrade_status: 'observe',
+    // TRADE LEDGER + neighbours (task-1530): ledger reads, a run's candidate record, outcome labels, the Telegram and
+    // live-signer STATE (never a key, an address or an exact balance) and the agent's own backtest requests
+    ledger_trades: 'observe',
+    ledger_positions: 'observe',
+    ledger_equity: 'observe',
+    ledger_summary: 'observe',
+    ledger_compare: 'observe',
+    candidate_dossier: 'observe',
+    outcomes_lookup: 'observe',
+    telegram_status: 'observe',
+    trading_status: 'observe',
+    backtest_requests: 'observe',
+    // THE JOURNEY (task-1647): a strategy's ladder and a forward test's report vs its backtest
+    strategy_journey: 'observe',
+    strategy_forward_report: 'observe',
     subscribe: 'observe',
     unsubscribe: 'observe',
     // ---- annotate: non-financial navigation + agent-owned annotations
@@ -68,6 +90,18 @@ export const TOOL_TIERS = Object.freeze({
     propose_alert: 'propose',
     propose_order_plan: 'propose',
     add_to_watchlist: 'propose',
+    // AUTOTRADE strategy proposals (task-1507): a JSON-patch proposal the user applies with a keypress on the Q screen
+    // (a LOOSER one needs a second keypress); /mode, /bankroll, the day budget and the exit-liquidity floor are user-only
+    strategy_propose_edit: 'propose',
+    strategy_propose_new: 'propose',
+    // a backtest REQUEST (task-1530): a file the user runs or dismisses with `dexterm autotrade requests`
+    backtest_request: 'propose',
+    // THE JOURNEY (task-1647): a paper forward test (the strategy's own bankroll, a bounded window, never real) and a
+    // promotion PROPOSAL the user applies (always-on: a key; real: their own caps + a typed phrase on their terminal).
+    // Vetted by hand: "promote" is on the never-list for agent tiers; this one only writes a proposal file.
+    strategy_forward_start: 'propose',
+    strategy_forward_stop: 'propose',
+    strategy_promote_propose: 'propose',
 });
 /** Tools that are proposals (write-shaped): they need an idempotency key and count against the proposal quota. */
 export const PROPOSAL_TOOLS = new Set(['propose_alert', 'propose_order_plan', 'add_to_watchlist']);
@@ -116,5 +150,5 @@ export function toolsForTier(tier) {
 export const TIER_LEGEND = {
     observe: 'read tools + streams',
     annotate: 'navigation, notes, tags',
-    propose: 'alerts, order plans, watch adds — as proposals',
+    propose: 'alerts, order plans, watch adds, strategy edits, backtest requests — as proposals',
 };

package/dist/packages/agents/src/tools.js

@@ -4,11 +4,18 @@
 // to the session's tier. Every tool here is read-only, navigation, or a PROPOSAL (user confirms with a
 // keypress). Nothing here builds, signs, sends, arms, raises a cap, or touches a wallet/mandate/signer —
 // the never-list (tiers.ts) refuses that shape before this table is ever consulted.
+import { MCAP_FIELD_HINT } from '../../data/src/basis.js';
 import { TOOL_TIERS } from "./tiers.js";
 const MINT = { type: 'string', pattern: '^[1-9A-HJ-NP-Za-km-z]{32,44}$', maxLength: 44 };
 const SYMBOL = { type: 'string', maxLength: 32 };
 const IDEMPOTENCY = { type: 'string', minLength: 8, maxLength: 64, pattern: '^[A-Za-z0-9_.:-]+$' };
 const URL = { type: 'string', maxLength: 512, pattern: '^https?://' };
+const STRATEGY = { type: 'string', pattern: '^[a-z][a-z0-9-]{1,31}$', maxLength: 32 };
+/** task-1530: an exit profile or exit reason code, and an autotrade run id. */
+const PROFILE = { type: 'string', pattern: '^[a-z][a-z0-9-]{0,31}$', maxLength: 32 };
+const RUN_ID = { type: 'string', pattern: '^[0-9TZ]+-[a-z][a-z0-9-]{1,31}-[0-9a-f]{4}$', maxLength: 64 };
+/** A JSON-patch op on a strategy (task-1507). The value is free JSON; the tool re-validates the whole result. */
+const PATCH_OPS = { type: 'array', maxItems: 20, items: { type: 'object', properties: { op: { type: 'string', enum: ['add', 'replace', 'remove'] }, path: { type: 'string', maxLength: 200, pattern: '^(/[^/]*)+$' }, value: { free: true } }, required: ['op', 'path'], additionalProperties: false } };
 /** Advertised tool table. Order is the order `tools/list` returns. */
 const TOOLS_DEF = [
     // ---------------------------------------------------------------- observe: bus-native
@@ -21,7 +28,7 @@ const TOOLS_DEF = [
     { name: 'screener_query', tier: 'observe', description: 'Screener rows with provenance. preset: "new" (youngest), "trending" (volume), "all".', inputSchema: { type: 'object', properties: { preset: { type: 'string', enum: ['new', 'trending', 'all'] }, limit: { type: 'integer', minimum: 1, maximum: 50 } }, additionalProperties: false } },
     { name: 'get_token', tier: 'observe', description: 'Token + Pair + Stats + Audit for a mint or symbol, each with source and age. Ambiguous symbols return candidates.', inputSchema: { type: 'object', properties: { mint: MINT, symbol: SYMBOL }, additionalProperties: false } },
     { name: 'get_dossier', tier: 'observe', description: 'One pre-assembled dossier (market, holders, security, candles, tape, creator) for a mint or symbol in a single round trip. Read `availability` for which sections are present.', inputSchema: { type: 'object', properties: { mint: MINT, symbol: SYMBOL, interval: { type: 'string', enum: ['1m', '5m', '15m', '1h', '4h', '1d'] } }, additionalProperties: false } },
-    { name: 'get_holders', tier: 'observe', description: 'Top holders (≤50) with the top10 share excluding LP.', inputSchema: { type: 'object', properties: { mint: MINT, top: { type: 'integer', minimum: 1, maximum: 50 } }, required: ['mint'], additionalProperties: false } },
+    { name: 'get_holders', tier: 'observe', description: 'Top holders (≤50) with the top10 share excluding pools, bonding curves, launch vaults, locks and burns, plus the raw top10.', inputSchema: { type: 'object', properties: { mint: MINT, top: { type: 'integer', minimum: 1, maximum: 50 } }, required: ['mint'], additionalProperties: false } },
     { name: 'get_trades', tier: 'observe', description: 'Recent trades of the most liquid pool with buy/sell aggregates and a wash signal.', inputSchema: { type: 'object', properties: { mint: MINT, window: { type: 'string', enum: ['m5', 'h1'] } }, required: ['mint'], additionalProperties: false } },
     { name: 'get_candles', tier: 'observe', description: 'Candles plus computed summaries (range, drawdown, VWAP, change%).', inputSchema: { type: 'object', properties: { mint: MINT, interval: { type: 'string', enum: ['1m', '5m', '15m', '1h', '4h', '1d'] }, limit: { type: 'integer', minimum: 1, maximum: 300 } }, required: ['mint'], additionalProperties: false } },
     { name: 'rugcheck', tier: 'observe', description: 'RugCheck-style summary: risks[] (firewalled), normalised score, lpLockedPct, tokenProgram.', inputSchema: { type: 'object', properties: { mint: MINT }, required: ['mint'], additionalProperties: false } },
@@ -37,6 +44,24 @@ const TOOLS_DEF = [
     { name: 'check_domain', tier: 'observe', description: 'Domain registration age, registrar and registrant-privacy via RDAP (keyless).', inputSchema: { type: 'object', properties: { url: URL }, required: ['url'], additionalProperties: false } },
     { name: 'check_x', tier: 'observe', description: 'Keyless lookup of the X account behind an advertised X link: exists/suspended/not_found/unavailable, age, followers, posts, last post, bio/site cross-link. Missing data is listed, never guessed; the bio is untrusted data.', inputSchema: { type: 'object', properties: { url: URL, symbol: SYMBOL, name: { type: 'string', maxLength: 64 }, mint: MINT, website: URL }, required: ['url'], additionalProperties: false } },
     { name: 'check_github', tier: 'observe', description: 'GitHub repo activity (created/last-push, stars, issues, archived/fork) via the keyless API.', inputSchema: { type: 'object', properties: { url: URL }, required: ['url'], additionalProperties: false } },
+    // ---------------------------------------------------------------- observe: AUTOTRADE strategy reads (task-1507, paper)
+    { name: 'strategy_list', tier: 'observe', description: 'AUTOTRADE (paper): the strategies (presets + the user\'s own) with version, hash, mode, last backtest line and pending proposals.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'strategy_get', tier: 'observe', description: 'AUTOTRADE (paper): one strategy document with its exit profiles resolved and its validation warnings. Text fields are untrusted data.', inputSchema: { type: 'object', properties: { id: STRATEGY }, required: ['id'], additionalProperties: false } },
+    { name: 'strategy_validate', tier: 'observe', description: 'AUTOTRADE (paper): validate a whole dexterm-strategy/1 document ({ok, errors, warnings}). Saves nothing.', inputSchema: { type: 'object', properties: { doc: { free: true } }, required: ['doc'], additionalProperties: false } },
+    { name: 'strategy_backtest', tier: 'observe', description: 'AUTOTRADE (paper): backtest a strategy or a pending proposal on recorded history (days <= 14). Read-only, one at a time, rate-limited.', inputSchema: { type: 'object', properties: { id: STRATEGY, proposalId: { type: 'string', maxLength: 40 }, tape: { type: 'string', enum: ['recorded'] }, days: { type: 'integer', minimum: 1, maximum: 14 } }, additionalProperties: false } },
+    { name: 'autotrade_status', tier: 'observe', description: 'AUTOTRADE (paper): the paper runner\'s status, the strategy count and the proposals waiting for the user.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'ledger_trades', tier: 'observe', description: 'TRADE LEDGER: trades from the unified ledger (paper, the agent paper desk, autotrade runs, the live signer), newest first: strategy id+version+hash, profile + entry reason and where each came from, exit reason, size and % of book, entry/exit price and market cap, fees, impact, hold, MFE/MAE, rug flag, wallet mode, tx signatures, model session ids and cost. PAPER rows are simulated.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 }, status: { type: 'string', enum: ['open', 'closed'] }, limit: { type: 'integer', minimum: 1, maximum: 200 }, fills: { type: 'boolean' } }, additionalProperties: false } },
+    { name: 'ledger_positions', tier: 'observe', description: 'TRADE LEDGER: the open trades (cost, % of book, held time, profile). No price fetch, no balance.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 }, limit: { type: 'integer', minimum: 1, maximum: 200 } }, additionalProperties: false } },
+    { name: 'ledger_equity', tier: 'observe', description: 'TRADE LEDGER: the realized equity curve and its max drawdown (at most 200 points).', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
+    { name: 'ledger_summary', tier: 'observe', description: 'TRADE LEDGER: win rate with its 95% interval, P/L, drawdown, rug rate, hold, MFE/MAE, declared-tag coverage, and breakdowns by profile, exit reason, strategy, source and mode.', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
+    { name: 'ledger_compare', tier: 'observe', description: 'TRADE LEDGER: one row per strategy version side by side (the forward-test table).', inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['paper', 'desk', 'autotrade', 'live'] }, mode: { type: 'string', enum: ['paper', 'devnet', 'live', 'real'] }, strategy: { type: 'string', maxLength: 50, pattern: '^[a-z][a-z0-9-]{0,31}(@[0-9a-z.]{1,16})?$' }, profile: PROFILE, exit_reason: PROFILE, mint: MINT, run_id: RUN_ID, days: { type: 'number', minimum: 0, maximum: 3650 } }, additionalProperties: false } },
+    { name: 'candidate_dossier', tier: 'observe', description: 'AUTOTRADE: what a run recorded about a candidate coin (rules matched, tick, the session\'s decisions, clamp, fills, close). Text fields are untrusted data.', inputSchema: { type: 'object', properties: { mint: MINT, run_id: RUN_ID }, required: ['mint'], additionalProperties: false } },
+    { name: 'outcomes_lookup', tier: 'observe', description: 'The recorder\'s code-only outcome labels for a coin, or for every candidate of a run (what the skips turned into). Not predictions.', inputSchema: { type: 'object', properties: { mint: MINT, run_id: RUN_ID, limit: { type: 'integer', minimum: 1, maximum: 100 } }, additionalProperties: false } },
+    { name: 'telegram_status', tier: 'observe', description: 'The Telegram connector\'s settings (enabled, paired chat count, tiers, approvals, notify). Never a token or an id.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'trading_status', tier: 'observe', description: 'The live trading signer\'s STATE: mode, kill switch, caps it enforces, a balance band. Never a key, an address or an exact balance; it cannot change anything.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'backtest_requests', tier: 'observe', description: 'Your backtest requests and their results once the user ran them.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { name: 'strategy_journey', tier: 'observe', description: 'AUTOTRADE: one of the user\'s strategies on the ladder draft → backtested → forward-tested → always-on → real: the evidence per rung on these exact rules and what the next rung needs. Read-only.', inputSchema: { type: 'object', properties: { id: STRATEGY }, required: ['id'], additionalProperties: false } },
+    { name: 'strategy_forward_report', tier: 'observe', description: 'AUTOTRADE (paper): a forward test next to the backtest of the same rules, with plain verdict lines (it says when a sample is too small). Read-only.', inputSchema: { type: 'object', properties: { id: STRATEGY, forwardId: { type: 'string', maxLength: 40 } }, additionalProperties: false } },
     // ---------------------------------------------------------------- annotate: non-financial navigation + agent-owned notes
     { name: 'open_token', tier: 'annotate', description: "Open a token's detail screen so the user can see it. `mint` must be one of the mints currently on screen (see screen_state). Non-financial navigation; it never trades.", inputSchema: { type: 'object', properties: { mint: MINT }, required: ['mint'], additionalProperties: false } },
     { name: 'show_in_screener', tier: 'annotate', description: "Show the screener with an optional filter / sort / highlighted mint. `filter` is dexterm's grammar; `highlight` must be a mint on screen.", inputSchema: { type: 'object', properties: { filter: { type: 'string', maxLength: 200 }, sort: { type: 'object', properties: { key: { type: 'string', maxLength: 24 }, dir: { type: 'string', enum: ['asc', 'desc'] } }, required: ['key'], additionalProperties: false }, highlight: MINT }, additionalProperties: false } },
@@ -45,9 +70,17 @@ const TOOLS_DEF = [
     // ---------------------------------------------------------------- propose: proposals the user must confirm with a keypress
     { name: 'propose_alert', tier: 'propose', description: 'Propose a watch alert on a mint (e.g. "mcap crosses 1M"). Appears as a PROPOSAL labelled with this agent; the user confirms with a keypress. You can never arm or fire it. Needs idempotency_key.', inputSchema: { type: 'object', properties: { mint: MINT, when: { type: 'string', minLength: 1, maxLength: 120 }, note: { type: 'string', maxLength: 200 }, idempotency_key: IDEMPOTENCY }, required: ['mint', 'when', 'idempotency_key'], additionalProperties: false } },
     { name: 'propose_order_plan', tier: 'propose', description: 'Propose a PAPER order plan (side, size, triggers) as a DRAFT proposal labelled with this agent. It is never armed, signed or sent; arming needs a physical keypress by the user and signer-side caps still apply. Needs idempotency_key.', inputSchema: { type: 'object', properties: { mint: MINT, side: { type: 'string', enum: ['buy', 'sell'] }, size: { type: 'string', maxLength: 40 }, triggers: { type: 'array', items: { type: 'string', maxLength: 80 }, maxItems: 8 }, note: { type: 'string', maxLength: 200 }, idempotency_key: IDEMPOTENCY }, required: ['mint', 'side', 'size', 'idempotency_key'], additionalProperties: false } },
+    { name: 'strategy_propose_edit', tier: 'propose', description: 'AUTOTRADE (paper): PROPOSE JSON-patch ops (<= 20) on one of the user\'s strategies, with a why. Returns the diff, validation and riskDelta. Never applied by you: the user applies it with a key on the Q screen (a looser edit needs a second key). /mode, /bankroll, /agent/budgetUsdPerDay and /execution/minExitLiquidityUsd are user-only.', inputSchema: { type: 'object', properties: { id: STRATEGY, ops: PATCH_OPS, why: { type: 'string', maxLength: 200 } }, required: ['id', 'ops', 'why'], additionalProperties: false } },
+    { name: 'strategy_propose_new', tier: 'propose', description: 'AUTOTRADE (paper): PROPOSE a new paper strategy copied from a preset under a new id and name, with optional ops (<= 20). Never applied by you; the user confirms it with a key.', inputSchema: { type: 'object', properties: { fromPreset: STRATEGY, id: STRATEGY, name: { type: 'string', maxLength: 80 }, ops: PATCH_OPS, why: { type: 'string', maxLength: 200 } }, required: ['fromPreset', 'id', 'name'], additionalProperties: false } },
+    { name: 'backtest_request', tier: 'propose', description: 'PROPOSE a longer backtest (a stored strategy id, 1 to 60 days, optionally every candidate) with a why. The user runs or dismisses it with `dexterm autotrade requests`; nothing runs here.', inputSchema: { type: 'object', properties: { id: STRATEGY, days: { type: 'integer', minimum: 1, maximum: 60 }, every_candidate: { type: 'boolean' }, why: { type: 'string', maxLength: 200 } }, required: ['id', 'why'], additionalProperties: false } },
+    { name: 'strategy_forward_start', tier: 'propose', description: 'AUTOTRADE (paper): start a forward test of one of the user\'s strategies on live data, on paper, with its own bankroll, for hours (0.25-72) and/or closed trades (1-200). Needs a backtest first. Never real; cannot set a bankroll or a cap.', inputSchema: { type: 'object', properties: { id: STRATEGY, hours: { type: 'number', minimum: 0.25, maximum: 72 }, trades: { type: 'integer', minimum: 1, maximum: 200 } }, required: ['id'], additionalProperties: false } },
+    { name: 'strategy_forward_stop', tier: 'propose', description: 'AUTOTRADE (paper): stop a running forward test (it flattens and writes its report; an early stop does not count).', inputSchema: { type: 'object', properties: { id: STRATEGY, forwardId: { type: 'string', maxLength: 40 } }, additionalProperties: false } },
+    { name: 'strategy_promote_propose', tier: 'propose', description: 'AUTOTRADE: PROPOSE promoting a strategy one rung (always-on or real) with an evidence card. Never applied by you and no rung can be skipped: the user applies always-on with a key, real only above their evidence floor (a completed forward test with their minimum of closed paper trades + a backtest), with their own caps and a typed phrase on their terminal.', inputSchema: { type: 'object', properties: { id: STRATEGY, to: { type: 'string', enum: ['always-on', 'real'] }, why: { type: 'string', maxLength: 200 } }, required: ['id', 'to', 'why'], additionalProperties: false } },
     { name: 'add_to_watchlist', tier: 'propose', description: "Propose adding a token to the user's watchlist. Appears as a PROPOSAL labelled with this agent. Needs idempotency_key.", inputSchema: { type: 'object', properties: { mint: MINT, note: { type: 'string', maxLength: 200 }, idempotency_key: IDEMPOTENCY }, required: ['mint', 'idempotency_key'], additionalProperties: false } },
 ];
-export const AGENT_TOOLS = Object.freeze(TOOLS_DEF);
+/** task-1537: the read tools whose results carry prices also carry market-cap twins; their descriptions say so + the basis. */
+const PRICE_FIELD_TOOLS = new Set(['screener_query', 'get_token', 'get_dossier', 'get_trades', 'get_candles', 'autotrade_status']);
+export const AGENT_TOOLS = Object.freeze(TOOLS_DEF.map((t) => (PRICE_FIELD_TOOLS.has(t.name) ? { ...t, description: `${t.description} ${MCAP_FIELD_HINT}` } : t)));
 const BY_NAME = new Map(AGENT_TOOLS.map((t) => [t.name, t]));
 /** The closed input schema the gate validates a call's arguments against, or undefined for an unknown tool. */
 export function toolSchema(name) {