dexterm-cli 0.1.6 → 0.2.0

package/dist/packages/cli/src/screens/autotrade-ui.js

@@ -0,0 +1,650 @@
+// dexterm — the AUTOTRADE (paper) screen's state and verbs (`Q`, task-1508, AUTOTRADE-SPEC §2b). PAPER ONLY.
+//
+// Five views on one screen key ('autotrade'), cycled with tab:
+//   list      presets + the user's strategies (mode, version, hash, last backtest, the active runner's marker)
+//   editor    one form, six sections; every field re-validates on change (validateStrategy), errors inline with
+//             their path; the screen filter is checked by the screener's own parser (error column highlighted);
+//             `s` saves only a valid draft (a new version through StrategyStore.patch), `u` undoes with the
+//             custom patch inverses (an unsaved edit first, else the last saved patch as a new version)
+//   compare   two strategies side by side (changed fields highlighted) + both backtests on one tape
+//   backtest  the §3 report (attribution, equity sparkline, clamps/refusals, limits) + a sweep with the held-out verdict
+//   runner    the runner's rendezvous file (heartbeat, halt, candidates, sessions, positions, ledger tail)
+//
+// What this screen can never do: switch a strategy to live (the editor refuses /mode, an import is forced to
+// paper), touch a wallet, a key, a mandate or the signer, or apply a model's edit (chat proposals are shown as
+// cards; applying them is the chat card's keypress flow). Kill / pause / flatten go through RunnerControl: the
+// runner's control file (task-1509 fileControl), the same request `dexterm autotrade stop|flatten` writes.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { applyOps, dextermHome } from '../../../custom/src/index.js';
+import { StrategyStore, MAX_OPS, recordBacktestEvidence, STRATEGY_ID, activeRunner, bumpPatch, fmtIssue, readControl, readFleetStatus, requestControl, runnerRendezvousPath, validateStrategy, } from '../../../autotrade/src/index.js';
+import { parseFilter } from "../screener/filter.js";
+import { proposalFilesFor, proposalSource } from "./autotrade-proposals.js";
+import { confirmPromote } from "./autotrade-journey.js";
+export const AUTOTRADE_VIEWS = ['list', 'editor', 'compare', 'backtest', 'runner'];
+export const VIEW_TITLE = { list: 'STRATEGIES', editor: 'EDITOR', compare: 'COMPARE', backtest: 'BACKTEST', runner: 'RUNNER', journey: 'JOURNEY' };
+export const SECTIONS = ['entry', 'exits', 'risk', 'sizing', 'agent', 'execution'];
+/** Who the journal names for an edit made on this screen (the same actor the CLI uses for the user's own edits). */
+export const TUI_ACTOR = 'user';
+/** The default backtest window (the chat tool's limit, §2a). */
+export const BACKTEST_DAYS = 14;
+/** The runner writes its heartbeat every 10 s (§6.3); older than this the view says stale. */
+export const HEARTBEAT_STALE_MS = 30_000;
+export const INPUT_MAX = 400;
+export const STUB_CONTROL = {
+    wired: false,
+    kill: () => 'kill is not wired in this build yet (it ships with the runner\'s stop command) · `dexterm wallet panic` stops every paper desk now',
+    pause: () => 'pause is not wired in this build yet (it ships with the runner\'s stop command)',
+    flatten: () => 'flatten is not wired in this build yet (it ships with the runner\'s flatten command) · nothing was sold',
+};
+/**
+ * The running runner's control file (task-1509, @dexterm/autotrade safety.ts): `!` is a soft stop (no new entries,
+ * sessions closed, orders dropped, mechanical exits keep running), `p` pauses or resumes new entries, `f` + y
+ * flattens. A stop or flatten is final for the run; the runner reads the request on its next tick.
+ */
+export function fileControl(home) {
+    const send = (action) => {
+        const r = activeRunner(home);
+        if (!r)
+            return 'no autotrade runner is running';
+        const w = requestControl(home, r.runId, action, 'tui');
+        if (!w.ok)
+            return w.why;
+        switch (action) {
+            case 'stop': return w.already ? 'stop already requested · mechanical exits keep running until nothing is held' : 'stop requested: no new entries, sessions close, orders dropped · mechanical exits keep running until nothing is held';
+            case 'flatten': return w.already ? 'flatten already requested' : 'flatten requested: every paper position sells at its next tick, then the runner stops';
+            case 'pause': return 'new entries paused · open positions keep their exits · p again resumes';
+            default: return 'new entries resumed';
+        }
+    };
+    return {
+        wired: true,
+        kill: () => send('stop'),
+        pause: () => {
+            const r = activeRunner(home);
+            const cur = readControl(home);
+            const paused = !!r && cur !== null && cur !== 'unreadable' && cur.runId === r.runId && cur.action === 'pause';
+            return send(paused ? 'resume-entries' : 'pause');
+        },
+        flatten: () => send('flatten'),
+    };
+}
+// ───────────────────────────── the runner rendezvous ─────────────────────────────
+export const RUNNER_SCHEMA = 'dexterm-autotrade-runner/1';
+/** The runner's rendezvous, `$DEXTERM_HOME/autotrade/runner-status.json` (the runner owns the path; runner.json next to it is
+ *  the runner config, §7.3), written atomically every heartbeat; this screen only reads it. */
+export { runnerRendezvousPath };
+export function readRunnerRendezvous(path, now = Date.now()) {
+    if (!existsSync(path))
+        return { kind: 'none', path };
+    let doc;
+    try {
+        doc = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (e) {
+        return { kind: 'bad', path, error: `not JSON: ${e.message}` };
+    }
+    const err = runnerShapeError(doc);
+    if (err)
+        return { kind: 'bad', path, error: err };
+    return { kind: 'ok', path, snap: doc, readAt: now };
+}
+function runnerShapeError(d) {
+    if (!d || typeof d !== 'object')
+        return 'not an object';
+    const o = d;
+    if (o.schema !== RUNNER_SCHEMA)
+        return `unknown rendezvous shape ${JSON.stringify(o.schema)} (expected ${RUNNER_SCHEMA})`;
+    // Paper, or real (task-1645: signals to the user's executor). Anything else is an error, never a running live runner.
+    if (o.mode !== 'paper' && o.mode !== 'real')
+        return `mode ${JSON.stringify(o.mode)}: this screen shows paper runners only (and real-mode signal runners)`;
+    for (const k of ['pid', 'startedAt', 'heartbeatAt'])
+        if (typeof o[k] !== 'number')
+            return `${k} is not a number`;
+    if (!['running', 'paused', 'halted', 'stopped'].includes(o.state))
+        return `unknown state ${JSON.stringify(o.state)}`;
+    for (const k of ['candidates', 'sessions', 'positions', 'ledgerTail'])
+        if (!Array.isArray(o[k]))
+            return `${k} is not a list`;
+    for (const k of ['strategy', 'book', 'spend'])
+        if (!o[k] || typeof o[k] !== 'object')
+            return `${k} is missing`;
+    return null;
+}
+export function heartbeatStale(r, now) {
+    return r.kind === 'ok' && now - r.snap.heartbeatAt > HEARTBEAT_STALE_MS;
+}
+export function defaultDeps(env = process.env, jobs = null) {
+    const home = dextermHome(env);
+    const proposalFiles = proposalFilesFor(env);
+    const source = proposalSource(proposalFiles);
+    return {
+        store: new StrategyStore({ env }),
+        jobs,
+        readRunner: () => readRunnerRendezvous(runnerRendezvousPath(home)),
+        readFleet: () => { const r = readFleetStatus(home); return r.ok ? r.status : null; },
+        control: fileControl(home),
+        proposals: source.cards,
+        proposalSource: source,
+        proposalFiles,
+        exportDir: join(home, 'exports'),
+        now: Date.now,
+    };
+}
+export function newAutotradeUi(deps) {
+    const ui = {
+        view: 'list', deps, entries: [], selected: 0, marked: [], notice: null, input: null, editor: null, compare: null,
+        focusId: null, backtests: new Map(), compareRun: null, sweep: null, runner: { kind: 'none', path: '' }, fleet: null, runnerReadAt: 0, confirm: null, review: null, journey: null,
+    };
+    reloadList(ui);
+    refreshRunner(ui);
+    return ui;
+}
+export function reloadList(ui) {
+    try {
+        ui.entries = ui.deps.store.list();
+    }
+    catch (e) {
+        ui.entries = [];
+        ui.notice = `strategies unreadable: ${e.message}`;
+    }
+    ui.selected = Math.max(0, Math.min(ui.entries.length - 1, ui.selected));
+}
+export function refreshRunner(ui) {
+    ui.runner = ui.deps.readRunner();
+    const f = ui.runner.kind === 'ok' ? ui.deps.readFleet?.() ?? null : null;
+    // Only the fleet the rendezvous names: a fleet-status.json left by an earlier parallel run is never shown as this one.
+    ui.fleet = f && ui.runner.kind === 'ok' && f.fleetId === ui.runner.snap.runId ? f : null;
+    ui.runnerReadAt = ui.deps.now();
+}
+/** The loop's 2 Hz tick: re-read the rendezvous every 2 s while the runner (or list, for its marker) is on screen. */
+export function autotradeTick(ui) {
+    if (ui.deps.now() - ui.runnerReadAt >= 2000)
+        refreshRunner(ui);
+}
+export const selectedEntry = (ui) => ui.entries[ui.selected];
+/** Whether the screen is capturing typed keys (an input line, a field value, or the flatten confirm). */
+export function autotradeCapturing(ui) {
+    return ui.input !== null || ui.confirm !== null || ui.review !== null || (ui.view === 'editor' && !!ui.editor?.typing);
+}
+// ───────────────────────────── the form ─────────────────────────────
+/** Every editable leaf of the six sections, in document order. Empty lists/objects and nulls are leaves typed as JSON. */
+export function fieldsOf(doc) {
+    const out = [];
+    const walk = (v, path, section) => {
+        if (v !== null && typeof v === 'object') {
+            const entries = Array.isArray(v) ? v.map((x, i) => [String(i), x]) : Object.entries(v);
+            if (!entries.length) {
+                out.push({ path, section, kind: 'json' });
+                return;
+            }
+            for (const [k, x] of entries)
+                walk(x, `${path}/${k}`, section);
+            return;
+        }
+        out.push({ path, section, kind: v === null ? 'null' : typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string' });
+    };
+    for (const s of SECTIONS)
+        walk(doc[s], `/${s}`, s);
+    return out;
+}
+export function getAt(doc, path) {
+    let o = doc;
+    for (const seg of path.split('/').slice(1)) {
+        if (o === null || typeof o !== 'object')
+            return undefined;
+        o = o[seg.replace(/~1/g, '/').replace(/~0/g, '~')];
+    }
+    return o;
+}
+/** Fields only the user may change by hand in a file, never on this screen (no path to live mode from the TUI). */
+export const READ_ONLY_PATHS = new Set(['/mode', '/id', '/schema', '/kind']);
+/** A typed value: strings stay verbatim (the screen filter, model ids, builtin refs), everything else is JSON. */
+export function parseFieldInput(text, kind) {
+    if (kind === 'string')
+        return { ok: true, value: text };
+    const t = text.trim();
+    if (!t)
+        return { ok: false, error: 'type a value (JSON: a number, true/false, null, a list or an object)' };
+    try {
+        return { ok: true, value: JSON.parse(t) };
+    }
+    catch {
+        return { ok: false, error: `not a JSON value: ${t.slice(0, 40)}` };
+    }
+}
+export function openEditor(ui, id) {
+    const got = ui.deps.store.get(id);
+    const raw = ui.deps.store.raw(id);
+    if (!got || !raw)
+        return `no strategy ${id}`;
+    const check = validateStrategy(raw);
+    ui.editor = { id, source: got.source, draft: raw, baseVersion: raw.version, edits: [], fields: fieldsOf(raw), selected: 0, check, typing: null };
+    ui.view = 'editor';
+    return got.source === 'preset' ? `${id} is a shipped preset (read-only): edits here are a draft · d on the list makes your own copy` : null;
+}
+/** Issues pinned to the first field at or under their path; the rest (whole-document ones) go to `loose`. */
+export function issuesByField(fields, issues) {
+    const at = new Map();
+    const loose = [];
+    for (const i of issues) {
+        const f = fields.find((x) => x.path === i.path || x.path.startsWith(`${i.path}/`));
+        if (!f || !i.path) {
+            loose.push(i);
+            continue;
+        }
+        at.set(f.path, [...(at.get(f.path) ?? []), i]);
+    }
+    return { at, loose };
+}
+export function beginFieldEdit(ui) {
+    const ed = ui.editor;
+    if (!ed)
+        return null;
+    const f = ed.fields[ed.selected];
+    if (!f)
+        return null;
+    if (READ_ONLY_PATHS.has(f.path))
+        return `${f.path} cannot be changed here`;
+    const cur = getAt(ed.draft, f.path);
+    // booleans flip in place (one keypress, re-validated like any edit)
+    if (f.kind === 'boolean')
+        return commitField(ui, f.path, !cur);
+    const text = f.kind === 'string' ? String(cur ?? '') : JSON.stringify(cur);
+    ed.typing = { path: f.path, text, check: null, parseError: null };
+    revalidateTyping(ui);
+    return null;
+}
+/** Re-validate the draft with the value being typed (every keystroke). */
+export function revalidateTyping(ui) {
+    const ed = ui.editor;
+    if (!ed?.typing)
+        return;
+    const f = ed.fields.find((x) => x.path === ed.typing.path);
+    const p = parseFieldInput(ed.typing.text, f?.kind ?? 'json');
+    if (!p.ok) {
+        ed.typing.parseError = p.error;
+        ed.typing.check = null;
+        return;
+    }
+    ed.typing.parseError = null;
+    try {
+        ed.typing.check = validateStrategy(applyOps(ed.draft, [{ op: 'replace', path: ed.typing.path, value: p.value }]).doc);
+    }
+    catch (e) {
+        ed.typing.parseError = e.message;
+        ed.typing.check = null;
+    }
+}
+export function commitTyping(ui) {
+    const ed = ui.editor;
+    if (!ed?.typing)
+        return null;
+    const { path, text } = ed.typing;
+    const f = ed.fields.find((x) => x.path === path);
+    const p = parseFieldInput(text, f?.kind ?? 'json');
+    if (!p.ok)
+        return p.error;
+    ed.typing = null;
+    return commitField(ui, path, p.value);
+}
+function commitField(ui, path, value) {
+    const ed = ui.editor;
+    if (READ_ONLY_PATHS.has(path))
+        return `${path} cannot be changed here`;
+    if (JSON.stringify(getAt(ed.draft, path)) === JSON.stringify(value))
+        return 'unchanged';
+    const op = { op: 'replace', path, value };
+    let next;
+    try {
+        next = applyOps(ed.draft, [op]);
+    }
+    catch (e) {
+        return e.message;
+    }
+    ed.draft = next.doc;
+    ed.edits.push({ op, inverse: next.inverse });
+    rebuildForm(ed, path);
+    return ed.check.ok ? null : `✗ ${ed.check.errors.length} problem${ed.check.errors.length === 1 ? '' : 's'} (fix before saving)`;
+}
+function rebuildForm(ed, keepPath) {
+    ed.check = validateStrategy(ed.draft);
+    ed.fields = fieldsOf(ed.draft);
+    if (keepPath) {
+        const i = ed.fields.findIndex((x) => x.path === keepPath || x.path.startsWith(`${keepPath}/`));
+        if (i >= 0)
+            ed.selected = i;
+    }
+    ed.selected = Math.max(0, Math.min(ed.fields.length - 1, ed.selected));
+}
+/** The unsaved edits as the fewest ops: the last value per path, in first-touched order. */
+export function pendingOps(ed) {
+    const last = new Map();
+    for (const e of ed.edits) {
+        last.delete(e.op.path);
+        last.set(e.op.path, e.op);
+    }
+    return [...last.values()];
+}
+/** `s`: only a valid draft is written, as a new version; the journal line carries the ops and their inverse. */
+export function saveEditor(ui) {
+    const ed = ui.editor;
+    if (!ed)
+        return 'nothing to save';
+    if (ed.source === 'preset')
+        return `${ed.id} is a shipped preset (read-only) · press d on the list to make your own copy, then edit that`;
+    if (!ed.edits.length)
+        return 'nothing to save (no changes)';
+    if (!ed.check.ok)
+        return `not saved: ${ed.check.errors.length} problem${ed.check.errors.length === 1 ? '' : 's'} · first: ${fmtIssue(ed.check.errors[0])}`;
+    const ops = pendingOps(ed);
+    const store = ui.deps.store;
+    const r = ops.length <= MAX_OPS
+        ? store.patch(ed.id, ops, { actor: TUI_ACTOR, why: 'edited on the Q screen' })
+        : store.update(ed.id, { ...ed.draft, version: bumpPatch(ed.baseVersion) }, { actor: TUI_ACTOR, why: 'edited on the Q screen' });
+    if (!r.ok)
+        return `not saved: ${fmtIssue(r.errors[0])}`;
+    const raw = store.raw(ed.id);
+    ui.editor = { ...ed, draft: raw, baseVersion: raw.version, edits: [], fields: fieldsOf(raw), check: validateStrategy(raw), typing: null };
+    reloadList(ui);
+    return `saved ${ed.id} v${r.strategy.version} (${r.strategy.hash}) · ${ops.length} change${ops.length === 1 ? '' : 's'} journaled`;
+}
+/**
+ * `u`: undo the newest unsaved edit with its inverse; with nothing unsaved, undo the last saved patch of this
+ * strategy by applying that journal line's inverse as a new version (refused when the file changed since).
+ */
+export function undoEditor(ui) {
+    const ed = ui.editor;
+    if (!ed)
+        return 'nothing to undo';
+    const last = ed.edits.pop();
+    if (last) {
+        try {
+            ed.draft = applyOps(ed.draft, last.inverse).doc;
+        }
+        catch (e) {
+            ed.edits.push(last);
+            return `undo failed: ${e.message}`;
+        }
+        rebuildForm(ed, last.op.path);
+        return `undid ${last.op.path}`;
+    }
+    if (ed.source === 'preset')
+        return 'nothing to undo';
+    const store = ui.deps.store;
+    const j = store.journal(ed.id).filter((x) => x.action !== 'remove');
+    const top = j[j.length - 1];
+    if (!top || top.action !== 'patch' || !top.inverse?.length)
+        return 'nothing to undo (the last saved change was not a field edit)';
+    const cur = store.get(ed.id);
+    if (!cur?.ok || cur.strategy.hash !== top.afterHash)
+        return 'undo refused: the file changed since the last saved edit';
+    const inverse = top.inverse.filter((x) => x.path !== '/version');
+    const r = store.patch(ed.id, inverse, { actor: TUI_ACTOR, why: `undo of v${top.version}` });
+    if (!r.ok)
+        return `undo refused: ${fmtIssue(r.errors[0])}`;
+    const raw = store.raw(ed.id);
+    ui.editor = { ...ed, draft: raw, baseVersion: raw.version, edits: [], fields: fieldsOf(raw), check: validateStrategy(raw), typing: null };
+    reloadList(ui);
+    return `undid v${top.version} → saved as v${r.strategy.version} (${r.strategy.hash})`;
+}
+/** The screen filter split for highlighting: the screener's tokens with their columns, and the parser's error column. */
+export function screenHighlight(src) {
+    const r = parseFilter(src);
+    return r.ok ? { error: null, at: null } : { error: r.error, at: r.at };
+}
+// ───────────────────────────── list verbs ─────────────────────────────
+export function beginNew(ui, dup) {
+    const e = selectedEntry(ui);
+    if (!e)
+        return 'no strategy selected';
+    if (!dup && e.source !== 'preset')
+        return 'n starts from a preset: select one (or d to duplicate this one)';
+    ui.input = { kind: dup ? 'dup' : 'new', text: `${e.id}-copy`.slice(0, 32), from: e.id };
+    return null;
+}
+export function beginImport(ui) { ui.input = { kind: 'import', text: '' }; }
+export function commitInput(ui) {
+    const inp = ui.input;
+    if (!inp)
+        return '';
+    ui.input = null;
+    const store = ui.deps.store;
+    if (inp.kind === 'import')
+        return importFile(ui, inp.text.trim());
+    const id = inp.text.trim();
+    if (!STRATEGY_ID.test(id))
+        return `bad id ${JSON.stringify(id)} (lowercase letters, digits and dashes, 2-32 chars)`;
+    const r = store.createFrom(inp.from, id, { actor: TUI_ACTOR, why: `${inp.kind === 'dup' ? 'duplicated' : 'new from preset'} ${inp.from} on the Q screen` });
+    if (!r.ok)
+        return `not created: ${fmtIssue(r.errors[0])}`;
+    reloadList(ui);
+    ui.selected = Math.max(0, ui.entries.findIndex((x) => x.id === id && x.source === 'user'));
+    return `created ${id} v${r.strategy.version} from ${inp.from} · e to edit`;
+}
+/** `i`: a strategy file into the store. Always paper, whatever the file says (§2c); validated; an existing id is refused. */
+export function importFile(ui, file) {
+    if (!file)
+        return 'no file';
+    let doc;
+    try {
+        doc = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        return `not imported: ${e.message}`;
+    }
+    if (!doc || typeof doc !== 'object')
+        return 'not imported: not a strategy document';
+    const forced = doc.mode !== 'paper';
+    doc = { ...doc, mode: 'paper' };
+    const r = ui.deps.store.create(doc, { actor: 'import', why: `import ${file} on the Q screen` });
+    if (!r.ok)
+        return `not imported: ${fmtIssue(r.errors[0])}`;
+    reloadList(ui);
+    return `imported ${r.strategy.id} v${r.strategy.version}${forced ? ' · mode forced to paper' : ''}`;
+}
+/** `x`: the strategy document as a shareable file (paper; never a key, a wallet or a mandate: the schema has none). */
+export function exportSelected(ui) {
+    const e = selectedEntry(ui);
+    if (!e)
+        return 'no strategy selected';
+    const raw = ui.deps.store.raw(e.id);
+    if (!raw)
+        return `${e.id} is not readable`;
+    mkdirSync(ui.deps.exportDir, { recursive: true, mode: 0o700 });
+    const path = join(ui.deps.exportDir, `strategy-${raw.id}-v${raw.version}.json`);
+    writeFileSync(path, JSON.stringify({ ...raw, mode: 'paper' }, null, 2) + '\n', { mode: 0o600 });
+    return `exported ${raw.id} v${raw.version} → ${path}`;
+}
+export function toggleMark(ui) {
+    const e = selectedEntry(ui);
+    if (!e)
+        return 'no strategy selected';
+    const key = e.id;
+    ui.marked = ui.marked.includes(key) ? ui.marked.filter((x) => x !== key) : [...ui.marked, key].slice(-2);
+    if (ui.marked.length === 2) {
+        ui.compare = { a: ui.marked[0], b: ui.marked[1], scroll: 0 };
+        ui.marked = [];
+        ui.view = 'compare';
+        return null;
+    }
+    return ui.marked.length ? `marked ${key} · c on a second strategy compares them` : `unmarked ${key}`;
+}
+/** Every leaf of both documents (union, a's order first); `changed` when the JSON differs. */
+export function compareRows(a, b) {
+    const leaves = (doc) => {
+        const m = new Map();
+        const walk = (v, path) => {
+            if (v !== null && typeof v === 'object') {
+                const entries = Array.isArray(v) ? v.map((x, i) => [String(i), x]) : Object.entries(v);
+                if (!entries.length) {
+                    m.set(path, JSON.stringify(v));
+                    return;
+                }
+                for (const [k, x] of entries)
+                    walk(x, `${path}/${k}`);
+                return;
+            }
+            m.set(path || '/', typeof v === 'string' ? v : JSON.stringify(v));
+        };
+        walk(doc, '');
+        return m;
+    };
+    const la = leaves(a), lb = leaves(b);
+    const paths = [...la.keys(), ...[...lb.keys()].filter((k) => !la.has(k))];
+    return paths.map((p) => ({ path: p, a: la.get(p) ?? '—', b: lb.get(p) ?? '—', changed: la.get(p) !== lb.get(p) }));
+}
+// ───────────────────────────── backtests ─────────────────────────────
+function resolved(ui, id) {
+    const g = ui.deps.store.get(id);
+    if (!g)
+        return `no strategy ${id}`;
+    if (!g.ok)
+        return `${id} is invalid: ${fmtIssue(g.errors[0])}`;
+    if (g.strategy.mode !== 'paper')
+        return `${id} is mode "${g.strategy.mode}": autotrade runs paper only`;
+    return g.strategy;
+}
+const errText = (e) => (e?.message ?? String(e)).split('\n')[0].slice(0, 200);
+/** `b`: backtest the selected (or focused) strategy on recorded history, off the render loop. */
+export function startBacktest(ui, id) {
+    const s = resolved(ui, id);
+    if (typeof s === 'string')
+        return s;
+    ui.focusId = id;
+    ui.view = 'backtest';
+    if (!ui.deps.jobs)
+        return 'backtests need the recorder history (not available in this mode)';
+    const cur = ui.backtests.get(s.hash);
+    if (cur?.status === 'running')
+        return 'a backtest of this version is already running';
+    const job = { key: s.hash, status: 'running', startedAt: ui.deps.now() };
+    ui.backtests.set(s.hash, job);
+    const until = ui.deps.now();
+    void ui.deps.jobs.backtest([s], { days: BACKTEST_DAYS, until }).then(([out]) => {
+        job.status = 'done';
+        job.result = out;
+        job.doneAt = ui.deps.now();
+        recordLine(ui, s, out.report);
+        // task-1647: the held-out split of a stored strategy is its journey evidence
+        if (out.evidence && ui.deps.store.get(s.id)?.ok) {
+            try {
+                recordBacktestEvidence(dirname(ui.deps.store.dir), out.evidence);
+            }
+            catch { /* evidence is best effort here */ }
+        }
+    }, (e) => { job.status = 'error'; job.error = errText(e); job.doneAt = ui.deps.now(); });
+    return `backtesting ${s.id} v${s.version} on the last ${BACKTEST_DAYS} days of recorded history…`;
+}
+function recordLine(ui, s, r) {
+    try {
+        ui.deps.store.recordBacktest({ hash: s.hash, t: ui.deps.now(), trades: r.trades, netUsd: r.netUsd, netPct: r.netPct, maxDrawdownPct: r.maxDrawdownPct, tape: `${r.tape.mints} coins ${r.tape.from ?? ''}..${r.tape.to ?? ''}` });
+        reloadList(ui);
+    }
+    catch { /* the line is a convenience for the list; never fail a backtest on it */ }
+}
+/** `b` on compare: both strategies on the SAME tape window. */
+export function startCompareBacktest(ui) {
+    if (!ui.compare)
+        return 'nothing to compare';
+    const a = resolved(ui, ui.compare.a), b = resolved(ui, ui.compare.b);
+    if (typeof a === 'string')
+        return a;
+    if (typeof b === 'string')
+        return b;
+    if (!ui.deps.jobs)
+        return 'backtests need the recorder history (not available in this mode)';
+    if (ui.compareRun?.status === 'running')
+        return 'already running';
+    const job = { key: `${a.hash}|${b.hash}`, status: 'running', startedAt: ui.deps.now() };
+    ui.compareRun = job;
+    void ui.deps.jobs.backtest([a, b], { days: BACKTEST_DAYS, until: ui.deps.now() }).then((outs) => {
+        job.status = 'done';
+        job.result = outs;
+        job.doneAt = ui.deps.now();
+        recordLine(ui, a, outs[0].report);
+        recordLine(ui, b, outs[1].report);
+    }, (e) => { job.status = 'error'; job.error = errText(e); job.doneAt = ui.deps.now(); });
+    return `backtesting ${a.id} and ${b.id} on one tape (last ${BACKTEST_DAYS} days)…`;
+}
+const r2 = (x) => Math.round(x * 100) / 100;
+const around = (x, lo, hi) => [...new Set([x * 0.67, x, x * 1.5].map((v) => Math.max(lo, Math.min(hi, Math.abs(v) >= 5 ? Math.round(v) : r2(v)))))];
+/**
+ * The sweep grid for a strategy's default exit profile (§3 skill-care method): cost-back level × bag trail for a
+ * moonbag profile, else the trail and the first take-profit, else the size. Three values each, around the current.
+ */
+export function defaultGrid(s) {
+    const p = s.exits.profiles[s.exits.default];
+    const g = {};
+    if (p.costRecovery) {
+        g['profile.costRecovery.atPct'] = around(p.costRecovery.atPct, 10, 10000);
+        if (p.bagTrail)
+            g['profile.bagTrail.trailPct'] = around(p.bagTrail.trailPct, 10, 90);
+    }
+    else {
+        if (p.trailingStop)
+            g['profile.trailingStop.trailPct'] = around(p.trailingStop.trailPct, 5, 60);
+        if (p.tpLadder.length)
+            g['profile.tpLadder.0.atPct'] = around(p.tpLadder[0].atPct, 0.1, 10000);
+    }
+    if (!Object.keys(g).length) {
+        if (s.sizing.mode === 'pct' && s.sizing.pct)
+            g['sizing.pct'] = around(s.sizing.pct, 0.1, 25);
+        else
+            g['risk.maxConcurrent'] = [...new Set([Math.max(1, s.risk.maxConcurrent - 1), s.risk.maxConcurrent, Math.min(20, s.risk.maxConcurrent + 1)])];
+    }
+    return g;
+}
+/** `w`: a held-out sweep (newest 30% of coins never tuned on; the verdict needs >= 20 trades both sides and a positive held-out net). */
+export function startSweep(ui, id) {
+    const s = resolved(ui, id);
+    if (typeof s === 'string')
+        return s;
+    ui.focusId = id;
+    ui.view = 'backtest';
+    if (!ui.deps.jobs)
+        return 'sweeps need the recorder history (not available in this mode)';
+    if (ui.sweep?.status === 'running')
+        return 'a sweep is already running';
+    const grid = defaultGrid(s);
+    const job = { key: s.hash, id: s.id, grid, status: 'running', startedAt: ui.deps.now() };
+    ui.sweep = job;
+    void ui.deps.jobs.sweep(s, grid, { days: BACKTEST_DAYS, until: ui.deps.now() }).then((res) => {
+        job.status = 'done';
+        job.result = res;
+        job.doneAt = ui.deps.now();
+    }, (e) => { job.status = 'error'; job.error = errText(e); job.doneAt = ui.deps.now(); });
+    return `sweeping ${s.id} over ${Object.keys(grid).join(' × ')} with a held-out split…`;
+}
+/** The strategy the backtest view is about: the focused one, else the list selection. */
+export function backtestSubject(ui) {
+    const id = ui.focusId ?? selectedEntry(ui)?.id ?? null;
+    if (!id)
+        return null;
+    const e = ui.entries.find((x) => x.id === id);
+    return { id, hash: e?.hash ?? null };
+}
+// ───────────────────────────── runner verbs ─────────────────────────────
+export function runnerVerb(ui, verb) {
+    if (ui.runner.kind !== 'ok')
+        return 'no autotrade runner is running';
+    if (verb === 'flatten') {
+        ui.confirm = { kind: 'flatten' };
+        return 'flatten: sell every paper position at the next tick? y to confirm, any other key cancels';
+    }
+    return verb === 'kill' ? ui.deps.control.kill() : ui.deps.control.pause();
+}
+export function confirmKey(ui, yes) {
+    const c = ui.confirm;
+    ui.confirm = null;
+    if (!c)
+        return '';
+    if (c.kind === 'promote')
+        return confirmPromote(ui, c.proposalId, yes);
+    return yes ? ui.deps.control.flatten() : 'flatten cancelled';
+}
+/** The views tab cycles through (compare only once two strategies were marked). */
+export function nextView(ui) {
+    const order = AUTOTRADE_VIEWS.filter((v) => (v !== 'compare' || ui.compare) && (v !== 'editor' || ui.editor));
+    ui.view = order[(order.indexOf(ui.view) + 1) % order.length] ?? 'list';
+}