dexterm-cli 0.1.1 → 0.1.3

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

@@ -6,7 +6,7 @@
 // mirror PROPOSAL and Tier 3 the capped auto-mirror, both behind the plan engine's own keypress gates.
 import { Canvas, header, footer, breakpoint, fmtAgeSec } from '../../../tui/src/index.js';
 import { headerModel } from "../state.js";
-import { shortAddr, autoSizeCap } from '../../../data/src/trade/copy/index.js';
+import { shortAddr, autoSizeCap, fmtHoldMs } from '../../../data/src/trade/copy/index.js';
 function fmtSol(n) { const s = n >= 0 ? '+' : '−'; return `${s}${Math.abs(n).toFixed(Math.abs(n) >= 10 ? 1 : 3)} SOL`; }
 function fmtUsdSigned(n) { const s = n >= 0 ? '+' : '−'; const a = Math.abs(n); return `${s}$${a >= 1000 ? (a / 1000).toFixed(1) + 'k' : a.toFixed(a >= 100 ? 0 : 2)}`; }
 function fmtUsdAbs(n) { if (n === null)
@@ -196,6 +196,95 @@ export function renderFollows(c, state) {
         y += 2;
         c.text(mbox.x + 1, y, gateOk ? 'Hold and release [enter] or [y] to turn auto ON (physical keypress) · [esc] leaves it OFF · a pipe/agent cannot' : '[esc] closes · accept the popup, then A again', { fg: t.accent, bg: mbg }, mbox.w - 2);
     }
+    // task-1399: the per-wallet DETAIL view (its own trades + positions + metrics, each with source + data age).
+    if (ui?.detail)
+        renderWalletDetail(c, state, now);
     const autoHint = (() => { const f = follows[Math.max(0, Math.min(follows.length - 1, ui?.selected ?? 0))]; const p = f ? svc?.auto?.policy(f.addr) : null; return p?.enabled ? 'auto OFF' : 'auto-mirror'; })();
-    footer(c, [['↑↓', 'move'], ['i', 'follow a wallet'], ['d', 'unfollow'], ['m', ui?.mirror ? (ui.mirror.result?.ok ? 'PROPOSE mirror' : 'close') : 'mirror ticket'], ['A', autoHint], ['r', 'poll now'], ['esc', 'back'], ['q', 'quit']], t.name);
+    const foot = ui?.detail
+        ? [['↑↓', 'scroll'], ['enter/esc', 'close'], ['q', 'quit']]
+        : [['↑↓', 'move'], ['enter', 'wallet view'], ['i', 'follow a wallet'], ['d', 'unfollow'], ['m', ui?.mirror ? (ui.mirror.result?.ok ? 'PROPOSE mirror' : 'close') : 'mirror ticket'], ['A', autoHint], ['r', 'poll now'], ['esc', 'back'], ['q', 'quit']];
+    footer(c, foot, t.name);
+}
+/**
+ * task-1399 — one followed wallet's DETAIL view: its own recent decoded trades and positions, plus the full metric
+ * set (realised PnL, win rate with n, median hold time, early-entry score, open), each labelled with its source
+ * (Helius history) and data age (time since the last poll). Read-only: nothing here trades, arms, proposes or signs.
+ */
+function renderWalletDetail(c, state, now) {
+    const t = c.theme;
+    const ui = state.copyUi;
+    const svc = state.copy;
+    if (!ui?.detail || !svc)
+        return;
+    const addr = ui.detail.wallet;
+    const f = svc.follows().find((x) => x.addr === addr);
+    const s = svc.stats(addr);
+    const trades = svc.trades(addr); // newest first
+    const top = 2, bottom = c.h - 1;
+    const mw = Math.min(c.w - 2, 104);
+    const mh = Math.max(10, bottom - top - 1);
+    const mx = Math.floor((c.w - mw) / 2), my = top + 1;
+    c.noRain(mx, my, mw, mh);
+    const label = f?.name ? ` · ${f.name}` : '';
+    const box = c.box(mx, my, mw, mh, { title: `WALLET${label} — read-only`, caption: 'its own trades + positions · every number: source + data age · not a recommendation', focus: true, bg: t.panelAlt });
+    const bg = box.bg;
+    let y = box.y;
+    c.text(box.x + 1, y, addr, { fg: t.text, bg }, box.w - 2);
+    y += 1;
+    const age = s.sample.asOf ? `${Math.max(0, Math.round((now - s.sample.asOf) / 1000))}s ago` : 'not fetched yet';
+    c.text(box.x + 1, y, `source ${s.sample.source} · ${age} · ${s.sample.note}`, { fg: t.dim, bg }, box.w - 2);
+    y += 1;
+    const pnl = `${fmtSol(s.realisedSol)}${s.realisedUsd !== null ? ` ${fmtUsdSigned(s.realisedUsd)}` : ''}`;
+    const wr = s.winRate === null ? `win rate n<10 (${s.wins}/${s.closed})` : `win rate ${Math.round(s.winRate * 100)}% (${s.wins}/${s.closed})`;
+    c.text(box.x + 1, y, `realised ${pnl} · ${wr} · hold ${fmtHoldMs(s.holdMedianMs)} · EES ${s.earlyEntry.score === null ? '—' : s.earlyEntry.score.toFixed(2)} · open ${s.open} · ${s.buys}b/${s.sells}s`, { fg: t.text, bg }, box.w - 2);
+    y += 1;
+    c.text(box.x + 1, y, `hold: ${s.holdNote} · EES: ${s.earlyEntry.note}`, { fg: t.dim, bg }, box.w - 2);
+    y += 2;
+    const footerY = box.y + box.h - 1;
+    const posCount = Math.min(s.positions.length, 6);
+    const posHeaderY = posCount ? footerY - posCount - 1 : footerY;
+    // RECENT TRADES (scrollable) fill the space above the positions block.
+    c.text(box.x + 1, y, 'RECENT TRADES', { fg: t.dim, bg });
+    y += 1;
+    if (!trades.length) {
+        c.text(box.x + 1, y, svc.status().state === 'unavailable' ? 'needs a free Helius key' : 'no swaps in fetched history', { fg: t.dim, bg, i: true });
+        y += 1;
+    }
+    else {
+        const roomRows = Math.max(1, posHeaderY - 1 - y);
+        const scroll = Math.max(0, Math.min(Math.max(0, trades.length - roomRows), ui.detail.scroll));
+        for (let i = scroll; i < trades.length && y < posHeaderY - 1; i++) {
+            const tr = trades[i];
+            const sideFg = tr.side === 'buy' ? t.up : tr.side === 'sell' ? t.down : t.muted;
+            let cx = c.text(box.x + 1, y, (tr.tKnown ? new Date(tr.t).toISOString().replace('T', ' ').slice(5, 19) : 'time unknown ').padEnd(15), { fg: t.dim, bg });
+            cx = c.text(cx + 1, y, tr.side.toUpperCase().padEnd(9), { fg: sideFg, bg, b: true });
+            cx = c.text(cx + 1, y, shortAddr(tr.mint).padEnd(11), { fg: t.text, bg });
+            cx = c.text(cx + 1, y, (tr.solDelta !== null ? `${Math.abs(tr.solDelta).toFixed(3)} SOL` : 'unpriced').padStart(11), { fg: t.muted, bg });
+            cx = c.text(cx + 1, y, fmtUsdAbs(tr.usd).padStart(8), { fg: t.text, bg });
+            if (tr.note)
+                c.text(cx + 1, y, `(${tr.note})`, { fg: t.dim, bg }, box.w - (cx + 1 - box.x) - 1);
+            y += 1;
+        }
+        const older = trades.length - scroll - roomRows;
+        if (older > 0)
+            c.textR(box.x + 1, posHeaderY - 1, box.w - 2, `… ${older} older (↑↓)`, { fg: t.dim, bg, i: true });
+    }
+    // POSITIONS block (fixed, bottom).
+    if (posCount) {
+        c.text(box.x + 1, posHeaderY, `POSITIONS · ${s.positions.length}`, { fg: t.dim, bg });
+        let py = posHeaderY + 1;
+        for (const p of s.positions.slice(0, posCount)) {
+            if (py >= footerY)
+                break;
+            let cx = c.text(box.x + 1, py, shortAddr(p.mint).padEnd(11), { fg: t.text, bg });
+            cx = c.text(cx + 1, py, (p.closed ? 'closed' : 'open').padEnd(7), { fg: p.closed ? t.muted : t.accent, bg });
+            cx = c.text(cx + 1, py, fmtSol(p.realisedSol).padStart(11), { fg: p.realisedSol > 0 ? t.up : p.realisedSol < 0 ? t.down : t.muted, bg });
+            cx = c.text(cx + 1, py, `${p.buys}b/${p.sells}s`.padEnd(8), { fg: t.dim, bg });
+            cx = c.text(cx + 1, py, `hold ${fmtHoldMs(p.holdMs)}`.padEnd(12), { fg: t.dim, bg });
+            if (p.flagged)
+                c.text(cx + 1, py, '(cost-0 lot: airdrop/transfer/unpriced)', { fg: t.dim, bg }, box.w - (cx + 1 - box.x) - 1);
+            py += 1;
+        }
+    }
+    c.textR(box.x + 1, footerY, box.w - 2, 'not a recommendation · a wallet\'s past fills say nothing about its next one', { fg: t.dim, bg, i: true });
 }

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

@@ -3,6 +3,7 @@
 // after the effects pass, so the card is crisp and no rain/scanline crosses it. Any key closes the
 // overlay; `?` toggles help.
 import { Canvas, DEFAULT_KEYMAP, mix } from '../../../tui/src/index.js';
+import { renderPnlOverlay } from "../pnl-app.js";
 /** Pretty single-key display for a keymap id ('enter' → '⏎', 'pagedown' → 'PgDn', 'ctrl+f' → '^F'). */
 function prettyKey(id) {
     switch (id) {
@@ -241,6 +242,8 @@ export function renderOverlay(c, state) {
         renderHelp(c, state);
     else if (state.overlay === 'workspaces')
         renderWorkspaces(c, state);
+    else if (state.overlay === 'pnl')
+        renderPnlOverlay(c, state);
     else if (state.overlay === 'links' && state.linkMenu) {
         const menu = state.linkMenu;
         const box = card(c, { w: 100, h: Math.min(24, menu.items.length * 2 + 6) }, 'ADVERTISED LINKS (UNTRUSTED)', 'j/k select · enter open · esc close');

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

@@ -172,5 +172,5 @@ export function renderPositions(c, state) {
     }
     if (v.history.length === 0)
         c.text(hb.x + 1, hb.y, 'no paper trades yet', { fg: t.dim, bg: hb.bg });
-    footer(c, [['esc', 'back'], ['r', 'refresh'], ['1-4', 'screens'], ['q', 'quit']], t.name, isCalm(state.vfx));
+    footer(c, [['esc', 'back'], ['r', 'refresh'], ['H', 'PnL card'], ['1-4', 'screens'], ['q', 'quit']], t.name, isCalm(state.vfx));
 }

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

@@ -39,7 +39,7 @@ export function renderRules(c, state) {
         cy += 1;
         c.text(box.x + 1, cy, 'dexterm rules add "<rule>"         the same from a shell · rules list | check | dry-run | remove | enable | disable', { fg: t.dim, bg }, box.w - 2);
         cy += 1;
-        c.text(box.x + 1, cy, 'fields: price mcap fdv liq vol5m vol1h vol24 holders org top10 dev lplocked bundled snipers cluster age m5 h1 h6 h24 buys sells bonding', { fg: t.dim, bg }, box.w - 2);
+        c.text(box.x + 1, cy, 'fields: price mcap fdv liq vol5m vol1h vol24 holders org top10 dev lplocked bundled snipers cluster fresh mintable freezable age m5 h1 h6 h24 buys sells bonding', { fg: t.dim, bg }, box.w - 2);
         cy += 1;
         c.text(box.x + 1, cy, 'signals: <field>.velocity (× its own pace) · <field>.delta (change in the window) · tags: launchpad: flag: verified: sus:', { fg: t.dim, bg }, box.w - 2);
         cy += 2;

package/dist/packages/cli/src/skill-eval-build.js

@@ -0,0 +1,109 @@
+// Build the skill backtest eval set from a recorder DB (task-1401). Read-only on the DB, no network.
+//
+// One row per coin. The label is the recorder's own outcome at the horizon (keyless proxy). The link evidence is
+// the DexScreener / Jupiter token record the app's cache already holds (ns `ds:token` / `jup:token`), used ONLY
+// when that record was fetched within `maxLagSec` AFTER the row's t0 anchor: the cache keeps the newest fetch per
+// coin, and a coin that kept trading was re-fetched long after t0 (when it may have bought a DexScreener profile),
+// while a coin that died stopped being fetched near t0. Taking a late record would leak the outcome into the
+// evidence, so a coin with no record inside the window is excluded and counted, never back-filled.
+//
+// The rows keep the mint, t0, the label, URL-free link features and the t0 snapshot numbers. No URL, name or
+// symbol is written (the name and symbol are read only to compute the domain-match boolean).
+import { linkFeatures } from '../../data/src/index.js';
+import { LABELER_VERSION } from '../../recorder/src/index.js';
+import { SKILL_EVAL_SCHEMA } from '../../packs/src/index.js';
+function readCache(db, ns, mint) {
+    const row = db.prepare('SELECT json, fetched_at FROM cache WHERE ns = ? AND key = ?').get(ns, mint);
+    if (!row)
+        return null;
+    try {
+        const j = JSON.parse(row.json);
+        const s = j.token?.socials ?? {};
+        return { fetched_at: Number(row.fetched_at), socials: { web: s.web ?? null, x: s.x ?? null, tg: s.tg ?? null }, symbol: j.token?.symbol ?? null, name: j.token?.name ?? null };
+    }
+    catch {
+        return null;
+    }
+}
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+const bool = (v) => (v === null || v === undefined ? null : Number(v) !== 0);
+export function buildSkillEvalSet(db, opts = {}) {
+    const horizon = opts.horizonSec ?? 259_200;
+    const lagMs = (opts.maxLagSec ?? 3_600) * 1000;
+    const testFrac = opts.testFrac ?? 0.3;
+    const excluded = { no_cached_link_record: 0, no_point_in_time_link_record: 0, no_t0_snapshot: 0, chain_verified_label: 0 };
+    const mints = db.prepare("SELECT DISTINCT mint FROM outcomes WHERE horizon_sec = ? AND label != 'unobserved'").all(horizon).map((r) => r.mint);
+    const outStmt = db.prepare("SELECT t0, label, label_tier FROM outcomes WHERE mint = ? AND horizon_sec = ? AND label != 'unobserved' ORDER BY t0 DESC");
+    const snapStmt = db.prepare('SELECT * FROM token_snapshots WHERE mint = ? AND t = ? AND is_t0 = 1 LIMIT 1');
+    const rows = [];
+    for (const mint of mints) {
+        const ds = readCache(db, 'ds:token', mint);
+        const jup = readCache(db, 'jup:token', mint);
+        if (!ds && !jup) {
+            excluded.no_cached_link_record++;
+            continue;
+        }
+        const outs = outStmt.all(mint, horizon);
+        let picked = null;
+        for (const o of outs) {
+            const t0 = Number(o.t0);
+            const srcs = [['jupiter', jup], ['dexscreener', ds]]
+                .filter((x) => !!x[1] && x[1].fetched_at >= t0 && x[1].fetched_at <= t0 + lagMs);
+            if (srcs.length) {
+                picked = { t0, label: o.label, label_tier: o.label_tier, srcs };
+                break;
+            }
+        }
+        if (!picked) {
+            excluded.no_point_in_time_link_record++;
+            continue;
+        }
+        if (picked.label_tier !== 'keyless-proxy') {
+            excluded.chain_verified_label++;
+            continue;
+        }
+        const snap = snapStmt.get(mint, picked.t0);
+        if (!snap) {
+            excluded.no_t0_snapshot++;
+            continue;
+        }
+        // The store's merge order: Jupiter first, then DexScreener (packages/data/src/store.ts).
+        const pick = (k) => picked.srcs.map(([, r]) => r.socials[k]).find((v) => v) ?? null;
+        const symbol = picked.srcs.map(([, r]) => r.symbol).find((v) => v) ?? snap.symbol;
+        const name = picked.srcs.map(([, r]) => r.name).find((v) => v) ?? snap.name;
+        const createdAt = num(snap.created_at);
+        rows.push({
+            mint, t0: picked.t0, split: 'train',
+            outcome: picked.label, bad: picked.label === 'rug' || picked.label === 'dead',
+            link: linkFeatures({ web: pick('web'), x: pick('x'), tg: pick('tg'), symbol, name }),
+            link_sources: picked.srcs.map(([s]) => s),
+            link_lag_sec: Math.round((Math.max(...picked.srcs.map(([, r]) => r.fetched_at)) - picked.t0) / 1000),
+            rug: {
+                freeze_auth: bool(snap.freeze_auth_enabled), mint_auth: bool(snap.mint_auth_enabled),
+                dev_pct: num(snap.dev_pct), top10_pct: num(snap.top_holders_pct), organic_score: num(snap.organic_score),
+                liquidity_usd: num(snap.liquidity_usd), price_usd: num(snap.price_usd), lp_locked_pct: num(snap.lp_locked_pct),
+                launchpad: snap.launchpad ?? null,
+                age_sec: createdAt ? Math.max(0, Math.round((picked.t0 - createdAt) / 1000)) : null,
+            },
+        });
+    }
+    rows.sort((a, b) => a.t0 - b.t0 || a.mint.localeCompare(b.mint));
+    const cutIdx = Math.min(rows.length, Math.floor(rows.length * (1 - testFrac)));
+    const cutoff = rows[cutIdx]?.t0 ?? Number.MAX_SAFE_INTEGER;
+    for (const r of rows)
+        r.split = r.t0 >= cutoff ? 'test' : 'train';
+    const train = rows.filter((r) => r.split === 'train');
+    const test = rows.filter((r) => r.split === 'test');
+    return {
+        schema: SKILL_EVAL_SCHEMA,
+        built_at: new Date(opts.now ?? Date.now()).toISOString(),
+        source: { kind: 'recorder', labeler_version: LABELER_VERSION, db_note: 'the app history DB on the machine that built it (outcomes + cache + token_snapshots); not shipped' },
+        horizon_sec: horizon,
+        label_rule: `recorder outcome at ${horizon}s (keyless proxy, labeler ${LABELER_VERSION}); bad = rug ∪ dead, ok = flat ∪ fade ∪ runner; unobserved dropped`,
+        evidence_rule: `link features from the cached DexScreener/Jupiter token record only when it was fetched within ${lagMs / 1000}s after the row's t0 (latest such t0 per coin); rug-check features from that t0 snapshot`,
+        split_rule: `by time: the latest ${Math.round(testFrac * 100)}% of rows by t0 (t0 ≥ ${new Date(cutoff).toISOString()}) are the held-out TEST split, fixed before tuning`,
+        cutoff_t0: cutoff,
+        counts: { rows: rows.length, train: train.length, test: test.length, bad_train: train.filter((r) => r.bad).length, bad_test: test.filter((r) => r.bad).length, excluded },
+        rows,
+    };
+}

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

@@ -0,0 +1,104 @@
+// `dexterm spectate …` — watch an agent drive dexterm (task-1406, "watch the agent cook").
+//
+//   dexterm spectate --replay FILE [--json]   replay a saved session file (demos + bug reports): fold the
+//                                             recorded agent actions into the screen model + activity panel
+//   dexterm spectate --info [--json]          show the live spectator stream endpoint (loopback + token)
+//                                             from ~/.dexterm/spectator.json, if a session is streaming
+//
+// Replay is deterministic and offline. The live stream itself is started by `dexterm agent serve --spectate`;
+// it is read-only, loopback-only and token-gated, and redacts wallet addresses/keys (see SPECTATOR.md).
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { FollowController, loadSpectatorRecording } from '../../agents/src/index.js';
+function flag(rest, name) { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; }
+function has(rest, name) { return rest.includes(name); }
+const USAGE = `dexterm spectate <command>
+  --replay FILE [--json]   replay a saved session (fold agent actions into the screen + activity panel)
+  --info [--json]          show the live stream endpoint from ~/.dexterm/spectator.json (if streaming)
+read-only · redacts wallet addresses/keys · the live stream is started by \`dexterm agent serve --spectate\``;
+function ago(t) { const s = Math.max(0, Math.round((Date.now() - t) / 1000)); return s < 60 ? `${s}s` : s < 3600 ? `${Math.floor(s / 60)}m` : `${Math.floor(s / 3600)}h`; }
+function age(s) { if (s == null)
+    return ''; return s < 60 ? ` · ${Math.round(s)}s old` : s < 3600 ? ` · ${Math.floor(s / 60)}m old` : ` · ${Math.floor(s / 3600)}h old`; }
+function renderView(view, meta, out) {
+    const s = view.screen;
+    out('SCREEN');
+    const bits = [`screen ${s.screen}`];
+    if (s.selectedMint)
+        bits.push(`token ${s.selectedMint}`);
+    if (s.feed)
+        bits.push(`feed ${s.feed}`);
+    if (s.filter)
+        bits.push(`filter ${s.filter}`);
+    if (s.highlight)
+        bits.push(`★ ${s.highlight}`);
+    if (s.watchlist.length)
+        bits.push(`watchlist ${s.watchlist.length}`);
+    out(`  ${bits.join(' · ')}`);
+    if (view.control === 'user')
+        out('  YOU HAVE TAKEN OVER (agent frozen)');
+    out('');
+    out('AGENTS');
+    if (!view.agents.length)
+        out('  (none)');
+    for (const a of view.agents)
+        out(`  [agent] ${a.name}  ${a.tier ?? '—'}  ${a.status}  · ${ago(a.lastAt)}`);
+    out('');
+    out(`ACTIVITY (${view.activity.length}${meta.redacted ? ' · redacted' : ' · full'})`);
+    for (const ev of view.activity) {
+        const ms = ev.ms != null ? ` ${Math.round(ev.ms)}ms` : '';
+        out(`  ${ago(ev.t).padStart(4)}  [agent] ${ev.agent}  ${ev.phase.padEnd(8)} ${(ev.tool ?? '').padEnd(16)} ${ev.summary ?? ''}${ms}${age(ev.dataAgeSec)}`);
+    }
+}
+export async function runSpectate(rest, io) {
+    const out = (s) => io.stdout.write(s + '\n');
+    const errOut = (s) => io.stderr.write(s + '\n');
+    const replayFile = flag(rest, '--replay');
+    if (replayFile) {
+        let recording;
+        try {
+            recording = loadSpectatorRecording(replayFile);
+        }
+        catch (e) {
+            errOut(`dexterm spectate: cannot read ${replayFile}: ${e.message}`);
+            return 1;
+        }
+        const follow = new FollowController({ activityCap: 500 });
+        for (const ev of recording.events)
+            follow.apply(ev);
+        if (has(rest, '--json')) {
+            out(JSON.stringify({ meta: recording.meta, view: follow.view() }));
+            return 0;
+        }
+        out(`replaying ${recording.events.length} event(s) from ${replayFile}${recording.meta.redacted ? ' (redacted)' : ''}`);
+        out('');
+        renderView(follow.view(), recording.meta, out);
+        return 0;
+    }
+    if (has(rest, '--info')) {
+        const home = io.env.DEXTERM_HOME || join(io.env.HOME || '', '.dexterm');
+        const path = join(home, 'spectator.json');
+        let info;
+        try {
+            info = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            errOut('no live spectator stream (start one with `dexterm agent serve --spectate`).');
+            return 1;
+        }
+        if (has(rest, '--json')) {
+            out(JSON.stringify(info));
+            return 0;
+        }
+        out(`live spectator stream on ws://127.0.0.1:${info.port} (loopback only).`);
+        out(`token is in ${path} (mode 0600) — pass it in the viewer's hello; never on a command line.`);
+        out('the stream is read-only and redacts wallet addresses/keys.');
+        return 0;
+    }
+    if (rest.length && !rest[0].startsWith('--')) {
+        errOut(`dexterm spectate: unknown subcommand ${JSON.stringify(rest[0])}`);
+        errOut(USAGE);
+        return 2;
+    }
+    out(USAGE);
+    return rest.length ? 2 : 0;
+}

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

@@ -120,7 +120,7 @@ export function plansRows(state) {
         return [];
     return state.plansUi?.tab === 'mandates' ? svc.listMandates() : svc.listPlans();
 }
-export function newFollowsUi() { return { selected: 0, input: null, notice: null, mirror: null, autoModal: null }; }
+export function newFollowsUi() { return { selected: 0, input: null, notice: null, mirror: null, autoModal: null, detail: null }; }
 /**
  * Tier 3: the auto-mirror service for this run, attached to the copy binding on first use. It sits on the plan
  * service (the signer trust domain) and the copy binding's market resolver; its journal is ~/.dexterm/copy.journal.