dexterm-cli 0.2.0 → 0.2.2

package/dist/packages/autotrade/src/runner.js

@@ -21,12 +21,13 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, write
 import { uptime } from 'node:os';
 import { join } from 'node:path';
 import { Ledger, writeJsonAtomic } from "./ledger.js";
-import { EntryRules, SimBook, clampEntry, simBuy, simSell } from "./engine.js";
+import { EntryRules, SimBook, clampEntry, simBuy, tierHardCapUsd, simSell } from "./engine.js";
 import { monitorTick } from "./monitor.js";
 import { buildDelta, renderDelta, renderEvent, urgent, view } from "./session.js";
 import { SessionGate, renderDossierRecord, renderPositionDossier, tapeDossierRecord } from "./sessions.js";
 import { DEFAULT_RUNNER_CONFIG, effectiveCaps } from "./runner-config.js";
 import { DEFAULT_PRICE_BASIS, fillMcaps, levelText } from "./basis-text.js";
+import { confidenceTierLine, tierRecord } from "./tiers.js";
 export { Ledger } from "./ledger.js";
 export function simExecutor(x) {
     return { name: 'sim', buy: (k, usd) => simBuy(k, usd, x), sell: (k, tokens, reason) => simSell(k, tokens, x, reason) };
@@ -34,10 +35,16 @@ export function simExecutor(x) {
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const REVIEW = ['time_review', 'time_tighten'];
 const INFO_ONLY = ['mechanical_exit', 'stuck'];
+/** Session ends that fail the same way every time: no new session for the rest of the run. */
+const GUARD_REASONS = new Set(['account-mismatch', 'not-tool-less', 'account-unavailable']);
 async function* fromArray(ticks) { for (const k of ticks)
     yield k; }
 export async function runAutotrade(o) {
     const s = o.strategy;
+    // 0.2.2: EXPERIMENTAL confidence tiers run on paper only: never in a real-signal run, never in any mode but paper
+    // (validateStrategy refuses the block outside paper and the engine refuses it too; this is the runner's own gate).
+    if (s.sizing.tiers && !(!o.real && s.mode === 'paper'))
+        throw new Error(`strategy ${s.id}: confidence tiers (sizing.tiers) are EXPERIMENTAL and PAPER ONLY: refused ${o.real ? 'in a real-signal run' : `in mode "${s.mode}"`} (remove sizing.tiers to run it there)`);
     // task-1571: autotrade runs on paper only. dexterm holds no key and places no live order; live trading happens in the
     // Telegram trading bot of the user's choice.
     // task-1645: mode "real" = the same paper engine, plus a LIVE TRADE FIRE signal per fill for the user's own executor;
@@ -76,6 +83,8 @@ export async function runAutotrade(o) {
     const skippedUntil = new Map();
     /** Coins the vet passed this run (a refused one goes to skippedUntil for good). */
     const vetted = new Set();
+    /** 0.2.2 confidence tiers: coins whose T0 (skip) line was already written at the pre-check. */
+    const tierSkipSaid = new Set();
     const orders = [];
     const refusals = {};
     const clampCount = {};
@@ -95,6 +104,24 @@ export async function runAutotrade(o) {
     const pumps = new Set();
     /** Proposals waiting for an answer, by mint (task-1527). */
     const approvalsOpen = new Map();
+    /** task-2156: the first-tranche dollars of each open approval (an in-flight entry for the tier clamp). */
+    const approvalUsd = new Map();
+    /** task-2156: entries decided but not filled (pending open orders + open approvals), other than `except`'s own. */
+    const inFlight = (except) => {
+        let opens = 0;
+        let usd = 0;
+        for (const q of orders)
+            if (q.kind === 'open' && q.mint !== except) {
+                opens++;
+                usd += q.usd;
+            }
+        for (const m of approvalsOpen.keys())
+            if (m !== except) {
+                opens++;
+                usd += approvalUsd.get(m) ?? Infinity;
+            }
+        return { opens, usd };
+    };
     ledger.add(t0, 'run_start', { strategy: s.id, version: s.version, strategyHash: s.hash, mode: s.mode, ...(o.real ? { tag: 'real-signal', accountId: o.real.accountId } : {}), ...(s.highRisk ? { highRisk: true } : {}), tape: o.tape?.source ?? o.source.name, ticks: tapeTicks?.length ?? null, decide: decideAuto ? 'auto' : s.entry.decide, ...(o.approvals ? { approvals: o.approvals.required(s) ? 'required' : 'when-asked' } : {}), pacing: pacing.mode, executor: exec.name, caps: capsView(gate), ...(o.account ? { account: o.account.id } : {}) });
     // task-1645 r2: a real run takes over the real positions an earlier run of this strategy left open (held.json),
     // so their exits keep firing. A profile the strategy no longer has falls back to its default profile.
@@ -121,27 +148,105 @@ export async function runAutotrade(o) {
     const count = (rule) => { refusals[rule] = (refusals[rule] ?? 0) + 1; };
     const refuse = (rule, data) => { count(rule); ledger.add(now, 'refused', { rule, ...data }); };
     // A vet that throws or hangs is a check that could not run: the strategy's `unknown` decides (reject by default).
-    const vetCoin = async (k) => {
+    const vetCoin = async (k, ctx) => {
         let r;
         try {
-            r = await o.vet(k);
+            r = await o.vet(k, ctx);
         }
         catch (e) {
             r = { ok: false, rule: 'vet-error', detail: e.message.slice(0, 160) };
         }
         if (r.ok) {
-            vetted.add(k.mint);
+            if (!r.recheck)
+                vetted.add(k.mint);
             if (r.note)
-                ledger.add(now, 'vetted', { mint: k.mint, note: r.note.slice(0, 200) });
+                ledger.add(now, 'vetted', { mint: k.mint, note: r.note.slice(0, 200), ...(r.sizeCapPct !== undefined ? { sizeCapPct: r.sizeCapPct } : {}) });
         }
         return r;
     };
+    const vetCtx = (k, sizeUsd, h) => ({ history: h, sizeUsd, exitFloorUsd: x.minExitLiquidityUsd, maxTop10Pct: s.entry.safety.maxTop10Pct, maxDevPct: s.entry.safety.maxDevPct, unknownHolders: s.entry.safety.unknownHolders });
+    const drainGuard = s.entry.safety.rugproof?.drainGuard ?? null;
+    const stuckSince = new Map();
+    /** The liquidity read each position was bought at (the drain guard's base). */
+    const entryLiq = new Map();
+    // Paper only: a real-signal bag is still in the user's wallet, so it keeps its exit signals and carries to the next
+    // real run (validateStrategy also refuses the option outside mode paper).
+    const writeOffMin = !o.real && s.mode === 'paper' ? x.stuckWriteOffMin ?? null : null;
+    /** Positions the pool probe saw drained (no feed-priced retry while it still says so). */
+    const drained = new Set();
+    /**
+     * task-1748, every step, for every open position:
+     *  - the drain guard: an exit verdict from the pool poller (SOL vault / Jupiter, <= 10 s apart), or this coin's own
+     *    feed liquidity down more than drainGuard.liqDropPct from the entry read, sells the whole position at once. The
+     *    sale is priced on the liquidity the guard saw (0 when the route is gone), not on a lagging feed row: an
+     *    emptied pool leaves nothing to sell into, the bag goes stuck and the write-off below closes it.
+     *  - execution.stuckWriteOffMin (paper): a bag stuck that long is closed at its realizable value (sells already
+     *    made kept, the rest 0), with a written_off event and a trade_closed line, so crash recovery never adopts it.
+     */
+    const sweepOpen = async (tick) => {
+        for (const p of [...book.open.values()]) {
+            if (p.status !== 'open')
+                continue;
+            const k = latest.get(p.mint) ?? p.lastTick;
+            if (drainGuard && !p.stuck) {
+                const v = o.drain?.verdict(p.id) ?? null;
+                const base = entryLiq.has(p.id) ? entryLiq.get(p.id) ?? null : (p.liqWindow[0]?.liq || null);
+                const own = tick && tick.mint === p.mint && base && tick.liq !== null && (1 - tick.liq / base) * 100 > drainGuard.liqDropPct
+                    ? { reason: 'drain-liquidity', detail: `liquidity $${Math.round(base)} -> $${Math.round(tick.liq)} since entry (-${((1 - tick.liq / base) * 100).toFixed(1)}% > ${drainGuard.liqDropPct}%)`, liqUsd: tick.liq } : null;
+                const hit = v ?? own;
+                if (hit) {
+                    ledger.add(now, 'drain_guard', { positionId: p.id, mint: p.mint, reason: hit.reason, detail: hit.detail, liqUsd: hit.liqUsd, source: v ? 'pool-probe' : 'feed' });
+                    say(`DRAIN GUARD ${p.symbol}: ${hit.detail}`);
+                    await sellPosition(p, { ...k, t: now, liq: hit.liqUsd ?? 0 }, p.tokens, hit.reason, hit.detail);
+                    // The probe saw the pool emptied or the route gone: the lagging feed must not "sell" the bag at its old
+                    // liquidity. While the probe still says so, the monitor's stuck retry is off for this position.
+                    if (v && p.status === 'open' && p.stuck)
+                        drained.add(p.id);
+                }
+            }
+            const since = stuckSince.get(p.id);
+            if (writeOffMin !== null && p.status === 'open' && p.stuck && since !== undefined && now - since >= writeOffMin * 60e3) {
+                const ct = book.close(p, now, 'written-off', true);
+                o.drain?.unwatch(p.id);
+                stuckSince.delete(p.id);
+                ledger.add(now, 'written_off', { positionId: p.id, mint: p.mint, stuckMin: Math.round((now - since) / 6e3) / 10, realizedUsd: ct.proceedsUsd, costUsd: ct.costUsd, why: `stuck ${writeOffMin} min under the exit floor: closed at realizable value (the rest counts 0)` });
+                ledger.add(now, 'trade_closed', { trade: { ...ct, fills: undefined }, entryPrice: p.entryPrice, peakPrice: p.peakPrice, troughPrice: p.troughPrice ?? null, writtenOff: true });
+                say(`WRITTEN OFF ${p.symbol}: stuck ${writeOffMin} min, ${ct.pnlPct}% realized`);
+            }
+            if (p.status === 'closed') {
+                const c = byPosition.get(p.id);
+                if (c) {
+                    if (c.inflight)
+                        await c.inflight;
+                    await closeCandidate(c, 'position-closed');
+                }
+            }
+        }
+    };
     const liveCandidateSessions = () => [...cands.values()].filter((q) => q.session && !q.positionId).length;
     const everyLive = () => [...new Set([...cands.values(), ...byPosition.values()])];
     const newCand = (k, matched, session, kind, positionId) => ({
         mint: k.mint, symbol: k.symbol, since: now, lastMatch: now, matched, session, sessionKind: kind, lastSent: view(k), lastSentT: now, seq: 0,
         inflight: null, pendingText: [], notes: [], closing: false, positionId, awaitingReview: null, oneShot: kind === 'position', costSeen: 0, turns: 0, lastDecision: null,
     });
+    /**
+     * Why the session's process ended on its own (null while alive). A session that proved the account or its tool list
+     * wrong (or had no account) blocks new sessions for the run; the guard is logged once, by the session that set it.
+     * Checked on every path that learns of a death: a null reply AND a close (a candidate's TTL can close a session that
+     * already died, before its null reply is read; task-1712).
+     */
+    let guardLogged = false;
+    const sessionDied = (c) => {
+        const died = c.session?.endReason?.() ?? null;
+        if (c.session && died && GUARD_REASONS.has(died)) {
+            if (!guardLogged && (gate.blocked === null || gate.blockedBy === c.session.id)) {
+                guardLogged = true;
+                ledger.add(now, 'guard', { state: died, effect: 'no new sessions this run; mechanical exits continue', sessionId: c.session.id });
+            }
+            gate.block(died, c.session.id);
+        }
+        return died;
+    };
     const closeCandidate = async (c, reason) => {
         if (c.closing)
             return;
@@ -163,8 +268,11 @@ export async function runAutotrade(o) {
                 c.costSeen = st.costUsd;
             }
             sessionCost += st.costUsd;
-            ledger.add(now, 'session_end', { sessionId: c.session.id, sessionKind: c.sessionKind, mint: c.mint, reason, turns: st.turns, costUsd: st.costUsd });
-            say(`session ${c.session.id} ended (${reason}) · ${st.turns} turns · $${st.costUsd.toFixed(4)}`);
+            // A session that had already failed its proof ended for that reason, whatever closed its candidate.
+            const died = sessionDied(c);
+            const why = died && GUARD_REASONS.has(died) ? died : reason;
+            ledger.add(now, 'session_end', { sessionId: c.session.id, sessionKind: c.sessionKind, mint: c.mint, reason: why, turns: st.turns, costUsd: st.costUsd });
+            say(`session ${c.session.id} ended (${why}) · ${st.turns} turns · $${st.costUsd.toFixed(4)}`);
         }
     };
     const sellPosition = async (p, k, tokens, reason, detail) => {
@@ -174,21 +282,37 @@ export async function runAutotrade(o) {
         if ('refused' in f) {
             if (!p.stuck) {
                 p.stuck = true;
+                stuckSince.set(p.id, now);
                 ledger.add(now, 'stuck', { positionId: p.id, mint: p.mint, why: f.refused, reason });
                 say(`STUCK ${p.symbol}: cannot sell (${f.refused})`);
             }
             return;
         }
         p.stuck = false;
+        stuckSince.delete(p.id);
         ledger.add(now, 'fill', { positionId: p.id, mint: p.mint, ...fillMcaps(fillView(f), k), detail, ...sigTag(f) });
         say(`SELL ${p.symbol} ${reason}: $${f.usd.toFixed(2)} at ${lvl(f.price, k)} (impact ${f.impactPct}%) — ${detail}`);
         const ct = book.sell(p, f);
+        if (ct)
+            o.drain?.unwatch(p.id);
         if (ct) {
             // task-1530: the price extremes the monitor saw while held (the trade ledger's MFE / MAE)
             ledger.add(now, 'trade_closed', { trade: { ...ct, fills: undefined }, entryPrice: p.entryPrice, peakPrice: p.peakPrice, troughPrice: p.troughPrice ?? null, ...(o.real ? { tag: 'real-signal' } : {}) });
             say(`CLOSED ${ct.symbol}: ${ct.pnlUsd >= 0 ? '+' : ''}$${ct.pnlUsd.toFixed(2)} (${ct.pnlPct}%) by ${ct.exitReason}`);
         }
     };
+    /** task-1748: a young or partly verified pool takes at most the vet's sizeCapPct of the strategy's pick. */
+    const capYoungPool = (r, c) => {
+        if (!r.ok || c.sizeCapPct === undefined)
+            return r;
+        const capUsd = Math.round(r.usd * c.sizeCapPct) / 100;
+        if (capUsd >= r.usd)
+            return r;
+        if (capUsd < s.sizing.minUsd)
+            return { ok: false, refused: 'below-min-after-rugproof-young-pool', clamps: [...r.clamps, { rule: 'rugproof-young-pool', fromUsd: r.usd, toUsd: capUsd }] };
+        const f = r.usd ? capUsd / r.usd : 1;
+        return { ...r, usd: capUsd, firstTrancheUsd: Math.round(r.firstTrancheUsd * f * 100) / 100, clamps: [...r.clamps, { rule: 'rugproof-young-pool', fromUsd: r.usd, toUsd: capUsd }] };
+    };
     /** Apply a validated decision at the current virtual time. */
     const apply = async (c, d) => {
         const k = latest.get(c.mint);
@@ -213,8 +337,10 @@ export async function runAutotrade(o) {
                 return;
             }
             const req = { profile: d.profile, sizePct: d.sizePct, sizeUsd: d.sizeUsd, confidence: d.confidence };
-            const r = clampEntry(book, k, req, killed);
-            ledger.add(now, 'clamp', { mint: c.mint, sessionId: c.session?.id ?? null, request: req, result: r.ok ? { ok: true, usd: r.usd, firstTrancheUsd: r.firstTrancheUsd, profile: r.profile.id, basis: r.basis, clamps: r.clamps } : r });
+            const r = capYoungPool(clampEntry(book, k, req, killed, now, inFlight(c.mint)), c);
+            ledger.add(now, 'clamp', { mint: c.mint, sessionId: c.session?.id ?? null, request: req, result: r.ok ? { ok: true, usd: r.usd, firstTrancheUsd: r.firstTrancheUsd, profile: r.profile.id, basis: r.basis, clamps: r.clamps } : r.tier ? { ok: false, refused: r.refused, clamps: r.clamps } : r, ...(r.tier ? { tier: tierRecord(r.tier) } : {}) });
+            if (r.tier)
+                say(confidenceTierLine(r.tier, k, r.ok ? r.usd : undefined));
             for (const cl of r.clamps)
                 clampCount[cl.rule] = (clampCount[cl.rule] ?? 0) + 1;
             if (!r.ok) {
@@ -299,7 +425,7 @@ export async function runAutotrade(o) {
                 const t = latest.get(c.mint);
                 if (!t)
                     return { ok: false, refused: 'no-tick' };
-                const rc = clampEntry(book, t, { profile: prof.id, sizeUsd: usd }, killed);
+                const rc = clampEntry(book, t, { profile: prof.id, sizeUsd: usd }, killed, now, inFlight(c.mint));
                 return rc.ok ? { ok: true, usd: rc.usd, clamps: rc.clamps.map((q) => q.rule) } : { ok: false, refused: rc.refused };
             },
             blocked: entryBlocked,
@@ -320,19 +446,32 @@ export async function runAutotrade(o) {
                     await closeCandidate(c, 'refused:approval-dropped');
                 return;
             }
-            const usd = Math.min(out.usd, r.usd);
-            const scale = r.usd > 0 ? usd / r.usd : 0;
             const t = latest.get(c.mint) ?? k;
+            let usd = Math.min(out.usd, r.usd);
+            // task-2156: a tiered entry re-clamps at the approval (one open, concurrency, room, a fresh tick), since other
+            // entries may have been decided or filled while it waited.
+            if (s.sizing.tiers) {
+                const rc = clampEntry(book, t, { profile: prof.id, sizeUsd: usd }, killed, now, inFlight(c.mint));
+                if (!rc.ok) {
+                    refuse('approval-dropped', { mint: c.mint, proposalId: out.proposalId, why: rc.refused });
+                    if (!c.closing)
+                        await closeCandidate(c, 'refused:approval-dropped');
+                    return;
+                }
+                usd = Math.min(usd, rc.usd);
+            }
+            const scale = r.usd > 0 ? usd / r.usd : 0;
             ledger.add(now, 'approval_granted', { mint: c.mint, proposalId: out.proposalId, via: out.via, usd, proofId: out.proofId ? `${out.proofId.slice(0, 6)}…` : null });
             say(`APPROVED ${k.symbol}: $${round2(usd)} via ${out.via}`);
             const ladder = (s.sizing.ladder ?? []).slice(1).map((tr) => ({ frac: tr.frac, atPct: tr.atPct, deadline: now + tr.withinMin * 60e3, usd: usd * tr.frac }));
             const first = round2(r.firstTrancheUsd * scale);
             orders.push({ mint: c.mint, fillAt: now + x.latencyMs, decidedPrice: t.price ?? 0, usd: first, firstUsd: first, profile: prof.id, sessionId: c.session?.id ?? null, trigger: c.matched, ladder, kind: 'open', ctx: { proofId: out.proofId, proposalId: out.proposalId, orderHash: out.orderHash } });
         };
+        approvalUsd.set(c.mint, r.firstTrancheUsd);
         const pending = o.approvals.request(prop, live)
             .catch((e) => ({ approved: false, state: 'ERROR', why: e instanceof Error ? e.message.slice(0, 120) : String(e) }))
             .then(settle)
-            .finally(() => { approvalsOpen.delete(c.mint); });
+            .finally(() => { approvalsOpen.delete(c.mint); approvalUsd.delete(c.mint); });
         approvalsOpen.set(c.mint, pending);
         // Lockstep (backtests, tests) waits for the answer; every other pacing lets it land when it lands.
         if (pacing.mode === 'lockstep')
@@ -356,14 +495,9 @@ export async function runAutotrade(o) {
             c.costSeen = Math.max(c.costSeen, r.costUsd);
         }
         if (!r || !r.decision.ok) {
-            const died = c.session.endReason?.() ?? null;
+            const died = sessionDied(c);
             if (!r)
                 ledger.add(now, 'session_timeout', { sessionId: c.session.id, mint: c.mint, ended: died });
-            if (died === 'account-mismatch' || died === 'not-tool-less' || died === 'account-unavailable') {
-                if (!gate.blocked)
-                    ledger.add(now, 'guard', { state: died, effect: 'no new sessions this run; mechanical exits continue', sessionId: c.session.id });
-                gate.block(died);
-            }
             if (review)
                 await noAnswer(review, !r ? (died ?? 'timeout') : 'invalid-decision');
             if (!r) {
@@ -437,11 +571,16 @@ export async function runAutotrade(o) {
             // Re-check at the fill, like a swap's slippage tolerance: a pool that drained or a price that ran
             // away between the decision and the fill refuses the order instead of buying into it.
             const prof0 = s.exits.profiles[q.profile];
-            const why = (k.liq ?? 0) < prof0.fit.minLiquidityUsd ? 'fill-liquidity-gone'
-                : k.price && q.decidedPrice && k.price > q.decidedPrice * (1 + x.slippageBps / 1e4) ? 'fill-slippage'
-                    // task-1538: on a shared paper account another strategy may have spent the cash since this order was decided;
-                    // the cash is held before the (async) fill so two strategies can never spend the same dollars.
-                    : book.account && !book.account.hold(q.usd) ? 'fill-account-cash' : null;
+            // task-2156: a tiered open re-checks one-open and concurrency at the fill (another entry may have filled first).
+            const tierBusy = s.sizing.tiers && q.kind === 'open'
+                ? (s.sizing.tiers.oneOpen !== false && book.open.size >= 1 ? 'fill-tier-one-open' : book.open.size >= s.risk.maxConcurrent ? 'fill-max-concurrent' : null)
+                : null;
+            const why = tierBusy ? tierBusy
+                : (k.liq ?? 0) < prof0.fit.minLiquidityUsd ? 'fill-liquidity-gone'
+                    : k.price && q.decidedPrice && k.price > q.decidedPrice * (1 + x.slippageBps / 1e4) ? 'fill-slippage'
+                        // task-1538: on a shared paper account another strategy may have spent the cash since this order was decided;
+                        // the cash is held before the (async) fill so two strategies can never spend the same dollars.
+                        : book.account && !book.account.hold(q.usd) ? 'fill-account-cash' : null;
             let f;
             try {
                 f = why ? { refused: why } : await exec.buy(k, q.usd, q.ctx);
@@ -477,6 +616,8 @@ export async function runAutotrade(o) {
             ledger.add(now, 'fill', { positionId: p.id, mint: p.mint, profile: prof.id, ...fillMcaps(fillView(f), k), bookUsd, ...(q.ctx?.proposalId ? { proposalId: q.ctx.proposalId } : {}), ...sigTag(f) });
             say(`BUY ${k.symbol} [${prof.id}]: $${f.usd.toFixed(2)} at ${lvl(f.price, k)}${f.partial ? ' (PARTIAL: impact cap)' : ''} · liq $${Math.round(k.liq ?? 0)}`);
             const c = cands.get(q.mint);
+            entryLiq.set(p.id, k.liq ?? null);
+            o.drain?.watch({ positionId: p.id, mint: p.mint, entryLiqUsd: k.liq ?? null, poolAddress: c?.pool?.address ?? null, quoteVault: c?.pool?.quoteVault ?? null, tokens: () => p.tokens });
             if (c) {
                 c.positionId = p.id;
                 byPosition.set(p.id, c);
@@ -617,6 +758,7 @@ export async function runAutotrade(o) {
             ledger.add(now, 'halt', { reason: book.state.halted });
             o.approvals?.cancelAll(`halted:${book.state.halted}`);
         }
+        await sweepOpen(k);
         // Held coin → the monitor (mechanical first, then wakes).
         const pos = book.open.get(k.mint);
         const chatSell = o.approvals?.takeExit?.(k.mint) ?? null;
@@ -646,7 +788,11 @@ export async function runAutotrade(o) {
                 }
             }
         }
+        else if (pos && drained.has(pos.id) && o.drain?.verdict(pos.id)) {
+            // task-1748: still drained per the pool probe: nothing sells into an emptied pool (the write-off closes it).
+        }
         else if (pos) {
+            drained.delete(pos.id);
             const prof0 = s.exits.profiles[pos.profileId];
             // task-1654: a real run's (or a paper scope's) maxHoldMinutes limit tightens the profile's holding cap (never loosens it).
             const holdCap = o.real?.maxHoldMinutes?.() ?? o.maxHoldMinutes?.() ?? null;
@@ -662,7 +808,16 @@ export async function runAutotrade(o) {
                 else if (a.kind === 'add') {
                     if (killed || book.state.halted)
                         continue;
-                    const room = Math.min(a.usd, book.state.cashUsd, (book.bookEquity() * s.risk.maxExposurePct) / 100 - book.exposureUsd());
+                    let room = Math.min(a.usd, book.state.cashUsd, (book.bookEquity() * s.risk.maxExposurePct) / 100 - book.exposureUsd());
+                    // 0.2.2 confidence tiers: the whole position (every tranche) stays within the engine's tier ceiling (fails closed).
+                    if (s.sizing.tiers) {
+                        const left = tierHardCapUsd(book.bookEquity()) - pos.costUsd;
+                        if (!(left >= s.sizing.minUsd)) {
+                            refuse('ladder-add-tier-hard-cap', { positionId: pos.id });
+                            continue;
+                        }
+                        room = Number.isFinite(room) ? Math.min(room, left) : 0;
+                    }
                     if (room < s.sizing.minUsd) {
                         refuse('ladder-add-no-room', { positionId: pos.id });
                         continue;
@@ -706,19 +861,31 @@ export async function runAutotrade(o) {
                 const sr = rules.screen(k);
                 if (sr.pass) {
                     // Cheap pre-check so a full book does not spawn sessions it could never act on.
-                    const pre = clampEntry(book, k, {}, killed);
-                    const v = pre.ok && o.vet && !vetted.has(k.mint) ? await vetCoin(k) : null;
+                    const pre = clampEntry(book, k, {}, killed, now, inFlight(k.mint));
+                    const v = pre.ok && o.vet && !vetted.has(k.mint) ? await vetCoin(k, vetCtx(k, pre.usd, h)) : null;
                     if (!pre.ok) {
                         if (!['already-open'].includes(pre.refused))
                             count(`precheck:${pre.refused}`);
+                        if (pre.tier?.tier === 'T0' && !tierSkipSaid.has(k.mint)) {
+                            tierSkipSaid.add(k.mint);
+                            say(confidenceTierLine(pre.tier, k));
+                        }
                     }
                     else if (v && !v.ok) {
-                        refuse(v.rule, { mint: k.mint, symbol: k.symbol, stage: 'vet', detail: v.detail });
-                        skippedUntil.set(k.mint, Infinity);
-                        say(`SKIP ${k.symbol} (${k.mint.slice(0, 4)}…): ${v.rule} (${v.detail})`);
+                        // task-1748: a time gate (pool age, the second liquidity read) looks again later; any other refusal is for good.
+                        const retry = v.retryAfterMs !== undefined;
+                        refuse(v.rule, { mint: k.mint, symbol: k.symbol, stage: 'vet', detail: v.detail, ...(retry ? { retryAfterMs: v.retryAfterMs } : {}) });
+                        skippedUntil.set(k.mint, retry ? now + v.retryAfterMs : Infinity);
+                        say(`SKIP ${k.symbol} (${k.mint.slice(0, 4)}…): ${v.rule} (${v.detail})${retry ? `; again in ${Math.round(v.retryAfterMs / 1000)} s` : ''}`);
                     }
                     else if (decideAuto) {
                         const cand = newCand(k, sr.matched, null, 'candidate', null);
+                        if (v?.ok) {
+                            if (v.sizeCapPct !== undefined)
+                                cand.sizeCapPct = v.sizeCapPct;
+                            if (v.pool)
+                                cand.pool = v.pool;
+                        }
                         cands.set(k.mint, cand);
                         ledger.add(now, 'candidate', { mint: k.mint, symbol: k.symbol, matched: sr.matched, tick: view(k) });
                         await apply(cand, { action: 'enter', reason: 'auto' });
@@ -734,6 +901,12 @@ export async function runAutotrade(o) {
                             const session = o.sessions(sid, s, { kind: 'candidate', mint: k.mint });
                             gate.opened('candidate');
                             const cand = newCand(k, sr.matched, session, 'candidate', null);
+                            if (v?.ok) {
+                                if (v.sizeCapPct !== undefined)
+                                    cand.sizeCapPct = v.sizeCapPct;
+                                if (v.pool)
+                                    cand.pool = v.pool;
+                            }
                             cands.set(k.mint, cand);
                             ledger.add(now, 'candidate', { mint: k.mint, symbol: k.symbol, matched: sr.matched, tick: view(k) });
                             ledger.add(now, 'session_start', { sessionId: sid, sessionKind: 'candidate', agent: session.kind, mint: k.mint, model: sessionModel(session, s), budgetUsd: gate.caps.budgetUsdPerSession });

package/dist/packages/autotrade/src/service-install.js

@@ -19,7 +19,7 @@
 // of its path, so a test home never replaces (or removes) the real one. A non-default home is passed as `--home`.
 // Only PATH is copied into the job's environment (the service needs to find `claude`); nothing else, no secrets.
 import { createHash } from 'node:crypto';
-import { join } from 'node:path';
+import { join, posix } from 'node:path';
 export const SERVICE_LABEL = 'xyz.dexterm.autotrade';
 export const INSTALL_MANIFEST_SCHEMA = 'dexterm-autotrade-service-install/1';
 /** The label for a DEXTERM_HOME: the default one, or one suffixed by a hash of the path. */
@@ -32,7 +32,9 @@ export function serviceLabel(dexHome, defaultHome) {
 export const ensureArgs = (s) => [s.nodePath, s.binPath, 'autotrade', 'service', 'ensure', '--quiet', ...(s.dexHome ? ['--home', s.dexHome] : [])];
 // ───────────────────────────── macOS ─────────────────────────────
 const xml = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-export const launchAgentPath = (s) => join(s.userHome, 'Library', 'LaunchAgents', `${s.label}.plist`);
+// LaunchAgent and systemd paths are macOS / Linux paths whatever host computes the plan (task-1712: a Windows host
+// joined them with `\`); the Windows task and the manifest live under the local dexHome and use the host's join.
+export const launchAgentPath = (s) => posix.join(s.userHome, 'Library', 'LaunchAgents', `${s.label}.plist`);
 export function renderLaunchAgent(s) {
     const args = ensureArgs(s).map((a) => `    <string>${xml(a)}</string>`).join('\n');
     const env = s.path ? `  <key>EnvironmentVariables</key>\n  <dict>\n    <key>PATH</key>\n    <string>${xml(s.path)}</string>\n  </dict>\n` : '';
@@ -70,7 +72,7 @@ ${env}  <key>StartInterval</key>
 }
 // ───────────────────────────── Linux (systemd user) ─────────────────────────────
 export const systemdUnit = (s) => s.label.replace(/^xyz\./, '').replace(/\./g, '-');
-export const systemdDir = (s) => join(s.userHome, '.config', 'systemd', 'user');
+export const systemdDir = (s) => posix.join(s.userHome, '.config', 'systemd', 'user');
 /** systemd quoting: double quotes, backslash and quote escaped, `%` doubled (specifier expansion). */
 const sd = (a) => `"${a.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%')}"`;
 export function renderSystemdService(s) {
@@ -189,7 +191,7 @@ export function installPlan(s, dexHome) {
         const dir = systemdDir(s);
         return {
             platform: s.platform, label: s.label, name: `${unit}.timer`,
-            files: [{ path: join(dir, `${unit}.service`), content: renderSystemdService(s) }, { path: join(dir, `${unit}.timer`), content: renderSystemdTimer(s) }],
+            files: [{ path: posix.join(dir, `${unit}.service`), content: renderSystemdService(s) }, { path: posix.join(dir, `${unit}.timer`), content: renderSystemdTimer(s) }],
             activate: [['systemctl', '--user', 'daemon-reload'], ['systemctl', '--user', 'enable', '--now', `${unit}.timer`]],
             deactivate: [['systemctl', '--user', 'disable', '--now', `${unit}.timer`]],
             notes: ['A systemd user timer runs while you are logged in; `loginctl enable-linger` (your choice) keeps it running after logout and from boot.'],

package/dist/packages/autotrade/src/sessions.js

@@ -131,12 +131,10 @@ class ClaudeCliSession {
                     tools: iso.tools, mcpServers: iso.mcpServers, plugins: iso.plugins, agents: iso.agents, skills: iso.skills, slashCommands: iso.slashCommands,
                 };
                 this.o.onInit?.(init);
-                if (!this.o.account.expectApiKeySource.includes(init.apiKeySource)) {
-                    this.kill('account-mismatch');
-                    return;
-                }
-                if (init.tools !== 0 || init.mcpServers !== 0) {
-                    this.kill('not-tool-less');
+                const failed = !this.o.account.expectApiKeySource.includes(init.apiKeySource) ? 'account-mismatch' : init.tools !== 0 || init.mcpServers !== 0 ? 'not-tool-less' : null;
+                if (failed) {
+                    this.o.onProofFailed?.(failed);
+                    this.kill(failed);
                     return;
                 }
                 continue;
@@ -229,6 +227,8 @@ export class SessionGate {
     pausedUntil = 0;
     /** Set when a session proved the account or the tool list wrong: no new session until the runner restarts. */
     blocked = null;
+    /** The session whose own failure set `blocked` (null when the block came from elsewhere, e.g. a sibling strategy). */
+    blockedBy = null;
     constructor(caps, guard, opts = {}) {
         this.caps = caps;
         this.guard = guard;
@@ -312,7 +312,12 @@ export class SessionGate {
     /** Are new sessions paused by the allowance guard right now (wall clock)? */
     paused() { return this.clock() < this.pausedUntil; }
     /** A misconfigured account (or a CLI that reports tools) fails the same way every time: stop spawning for this run. */
-    block(reason) { this.blocked ??= reason; }
+    block(reason, sessionId) {
+        if (this.blocked !== null)
+            return;
+        this.blocked = reason;
+        this.blockedBy = sessionId ?? null;
+    }
 }
 const isRec = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 /** The MCP-shaped sections a replay can honestly fill from the tape row; everything else is named as unavailable. */
@@ -455,6 +460,7 @@ export function claudeSessionFactory(f) {
             catch (e) {
                 failed = 'account-unavailable';
                 f.log('session_account_error', { sessionId: id, error: e.message });
+                f.gate.block(failed, id);
                 return null;
             }
             if (closed)
@@ -467,6 +473,9 @@ export function claudeSessionFactory(f) {
                 onRateLimit: (r) => { f.gate.rateLimit(r); f.log('allowance', { sessionId: id, status: r.status, fiveHour: r.fiveHour, sevenDay: r.sevenDay, resetsAt: r.resetsAt }); },
                 onLate: (text) => f.log('late_reply_ignored', { sessionId: id, why: 'arrived after decideWithinSec', text: text.slice(0, 400) }),
                 onRaw: f.onRaw ? (line) => f.onRaw(id, line) : undefined,
+                // The gate closes at the failed proof itself, not when the runner later reads this session's (null) reply: a
+                // candidate that closes first (its TTL) must not leave the gate open for more sessions on the wrong account.
+                onProofFailed: (why) => f.gate.block(why, id),
             });
             return inner;
         })());

package/dist/packages/autotrade/src/store.js

@@ -81,7 +81,7 @@ export class StrategyStore {
                 return { id, source, ok: false, errors: r.errors, warnings: r.warnings };
             const s = r.strategy;
             return {
-                id, source, ok: true, name: s.name, version: s.version, hash: s.hash, mode: s.mode, ...(s.highRisk ? { highRisk: true } : {}), profiles: Object.keys(s.exits.profiles), warnings: r.warnings,
+                id, source, ok: true, name: s.name, version: s.version, hash: s.hash, mode: s.mode, ...(s.highRisk ? { highRisk: true } : {}), ...(s.sizing.tiers ? { experimentalTiers: true } : {}), profiles: Object.keys(s.exits.profiles), warnings: r.warnings,
                 ...(last[s.hash] ? { lastBacktest: last[s.hash] } : {}),
             };
         };