dexterm-cli 0.1.7 → 0.2.1

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)}`;
@@ -93,13 +95,18 @@ const finiteOr = (x, d = null) => (typeof x === 'number' && Number.isFinite(x) ?
 // eslint-disable-next-line no-control-regex
 const UNSAFE_RE = /[\u0000-\u001f\u007f-\u009f​-‏‪-‮⁦-⁩]/g;
 const shortStr = (x, max) => (typeof x === 'string' ? x.replace(UNSAFE_RE, '').slice(0, max) : '');
-const isMintish = (x) => typeof x === 'string' && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(x);
+const isFullMint = (x) => typeof x === 'string' && /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(x);
+/** A mint as the redactor leaves it (maskAddress: head4…tail4). */
+const isMaskedMint = (x) => typeof x === 'string' && /^[1-9A-HJ-NP-Za-km-z]{4}…[1-9A-HJ-NP-Za-km-z]{4}$/.test(x);
 /**
  * task-1466: re-validate a detail read off the local channel (shape, types, lengths). The channel is our own
  * server's 0600 file and token-checked, but the viewer still treats it as data: anything malformed is dropped,
  * strings are stripped of control/bidi characters and capped, numbers must be finite. Returns null when empty.
  */
-export function sanitizeDetail(raw) {
+export function sanitizeDetail(raw, opts = {}) {
+    // task-1427: a detail read off the SHARED stream (or a saved file) is already redacted, so its mints are head…tail;
+    // `masked` accepts that shape (and only that shape) instead of a full mint. The local channel keeps the strict check.
+    const isMintish = (x) => (opts.masked ? isMaskedMint(x) : isFullMint(x));
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;
     const r = raw;
@@ -138,6 +145,27 @@ export function sanitizeDetail(raw) {
         out.caps = { perTradeUsd: cp.perTradeUsd, totalUsd: cp.totalUsd, maxPriceImpactPct: finiteOr(cp.maxPriceImpactPct) };
     if (typeof r.refusal === 'string' && r.refusal)
         out.refusal = shortStr(r.refusal, 40);
+    const h = r.holders;
+    const top10 = h ? finiteOr(h.top10Pct) : null;
+    if (h && top10 !== null && top10 >= 0 && top10 <= 100 && (h.basis === 'ex-pools' || h.basis === 'raw')) {
+        const count = finiteOr(h.count), ageSec = finiteOr(h.ageSec);
+        out.holders = { top10Pct: top10, count: count !== null && count >= 0 ? Math.round(count) : null, basis: h.basis, ageSec: ageSec !== null && ageSec >= 0 ? ageSec : null };
+    }
+    if (Array.isArray(r.liveFlags)) {
+        const LEVELS = ['up', 'down', 'info', 'warn'];
+        const sigs = r.liveFlags.slice(0, 8).flatMap((x) => {
+            const o = x;
+            if (!o || typeof o !== 'object')
+                return [];
+            const kind = shortStr(o.kind, 16), title = shortStr(o.title, 24), text = shortStr(o.text, 120);
+            const at = finiteOr(o.at), ageSec = finiteOr(o.ageSec);
+            if (!kind || !title || at === null || ageSec === null || ageSec < 0 || !LEVELS.includes(o.level))
+                return [];
+            return [{ kind, level: o.level, title, text, source: shortStr(o.source, 24) || '?', at, ageSec, stale: o.stale === true }];
+        });
+        if (sigs.length)
+            out.liveFlags = sigs;
+    }
     return Object.keys(out).length ? out : null;
 }
 // ---------------------------------------------------------------------------------------------------

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

@@ -46,6 +46,9 @@ export const TOOL_TIERS = Object.freeze({
     // agents in task-1405 so a bring-your-own-agent gets the same code-stage analysis the built-in analyst does.
     analyze_token: 'observe',
     narrative_board: 'observe',
+    narratives_top: 'observe',
+    narrative_detail: 'observe',
+    narrative_of: 'observe',
     rug_backtest: 'observe',
     kb_lookup: 'observe',
     kb_search: 'observe',
@@ -76,6 +79,9 @@ export const TOOL_TIERS = Object.freeze({
     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
@@ -93,6 +99,12 @@ export const TOOL_TIERS = Object.freeze({
     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']);

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

@@ -35,6 +35,9 @@ const TOOLS_DEF = [
     { name: 'get_dev_history', tier: 'observe', description: 'Creator address and prior-launch forensics. Tier-1 fields need a key and are null on the keyless tier.', inputSchema: { type: 'object', properties: { mint: MINT }, required: ['mint'], additionalProperties: false } },
     { name: 'analyze_token', tier: 'observe', description: 'Deterministic token-dossier analysis pack: numeric features, named rule flags, a WATCH/SPECULATIVE/AVOID verdict, a p(rug) heuristic and data ages. No model, no token cost; a reasoning stage may only tighten the verdict, never loosen it.', inputSchema: { type: 'object', properties: { mint: MINT, symbol: SYMBOL, interval: { type: 'string', enum: ['1m', '5m', '15m', '1h', '4h', '1d'] } }, additionalProperties: false } },
     { name: 'narrative_board', tier: 'observe', description: 'The narrative board over recorded + trending tokens: per-narrative volume, new launches, runners and a "what is working" score. No model; returns a note when there is no recorded history yet.', inputSchema: { type: 'object', properties: { window: { type: 'string', enum: ['1h', '24h'] }, limit: { type: 'integer', minimum: 1, maximum: 50 }, summary: { type: 'boolean' } }, additionalProperties: false } },
+    { name: 'narratives_top', tier: 'observe', description: 'MEMES + NARRATIVES tracker: the hottest name/ticker-theme clusters of the last 26 h with lifecycle (spark/ignition/peak/fading/dead), copy-cat saturation, volume share and a traction score. Measured heat, not advice.', inputSchema: { type: 'object', properties: { limit: { type: 'integer', minimum: 1, maximum: 50 }, lifecycle: { type: 'string', enum: ['spark', 'ignition', 'peak', 'fading'] } }, additionalProperties: false } },
+    { name: 'narrative_detail', tier: 'observe', description: 'One narrative by id: per-window metrics, lifecycle rule and member coins in spawn order. Measured heat, not advice.', inputSchema: { type: 'object', properties: { id: { type: 'string' }, limit: { type: 'integer', minimum: 1, maximum: 100 } }, required: ['id'], additionalProperties: false } },
+    { name: 'narrative_of', tier: 'observe', description: 'Which narrative a coin belongs to: label, lifecycle, rank, spawn index, saturation. Measured heat, not advice.', inputSchema: { type: 'object', properties: { mint: { type: 'string' } }, required: ['mint'], additionalProperties: false } },
     { name: 'rug_backtest', tier: 'observe', description: 'Backtest the rug model or recorded pack verdicts against RECORDED outcomes: honest precision/recall, Brier, AUC and calibration. Leakage-free by construction; returns a note when there is not enough history. Read-only.', inputSchema: { type: 'object', properties: { kind: { type: 'string', enum: ['heuristic', 'pack_verdicts'] }, horizon_sec: { type: 'integer', enum: [3600, 7200, 21600, 86400, 259200] }, positive_labels: { type: 'array', items: { type: 'string', enum: ['rug', 'dead', 'fade', 'flat', 'runner'] }, maxItems: 5 } }, additionalProperties: false } },
     { name: 'kb_lookup', tier: 'observe', description: 'One knowledge-base entry by id (mechanics / patterns / glossary). KB never holds facts about a live token.', inputSchema: { type: 'object', properties: { id: { type: 'string', maxLength: 64 } }, required: ['id'], additionalProperties: false } },
     { name: 'kb_search', tier: 'observe', description: 'Search the knowledge base; returns ids, titles and an excerpt.', inputSchema: { type: 'object', properties: { query: { type: 'string', maxLength: 200 }, limit: { type: 'integer', minimum: 1, maximum: 10 } }, required: ['query'], additionalProperties: false } },
@@ -50,16 +53,18 @@ const TOOLS_DEF = [
     { 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'] }, 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'] }, 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'] }, 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'] }, 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'] }, 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_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 } },
@@ -71,6 +76,9 @@ const TOOLS_DEF = [
     { 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 } },
 ];
 /** task-1537: the read tools whose results carry prices also carry market-cap twins; their descriptions say so + the basis. */