@chessceo/mcp 0.49.11 → 0.50.0

package/dist/analysis/deep.js

@@ -1,22 +1,11 @@
-// deep_analyse: async background job for a SINGLE long Stockfish think
-// on ONE position (up to 5 min movetime). Same start / status / cancel
-// shape as auto_evaluate, but different intent — the point is to free
-// the tool response path from a 5-minute wait AND to keep the Lc0 slot
-// free on the combo so the LLM can keep calling
-// `cloud_analyse({engines: ["lc0"]})` for other positions while the
-// deep SF think runs.
-//
-// Concretely: the job fires an unawaited authedRequest to the backend
-// with engines=["stockfish"] + long movetime; the backend's per-engine
-// semaphore lets that hold only the SF slot for the duration. The
-// MCP-side promise resolves when the long HTTP call returns (nginx
-// proxy_read_timeout is bumped to 420s on /api/agent/ to cover 5-min
-// movetime + engine bestmove grace).
-//
-// Extracted from index.ts in v0.44 as part of the file split.
-import { authedRequest } from "../http.js";
-import { analysisToStoredEval, convertCloudSnapshotResponse } from "./response.js";
-import { analyseRouting, resolveFromNodeOrFen, storeEvalOnNode, } from "./file_handle.js";
+// deep_analyse: async background job for ONE long think on ONE position
+// (up to 5 min movetime), on any engine (default Stockfish). Same
+// start / status / cancel shape as auto_evaluate. The long call holds only
+// that engine's slot, so the other engines stay usable through
+// cloud_analyse while it runs. nginx proxy_read_timeout on /api/agent/ is
+// 420s to cover a 5-min think plus the bestmove grace.
+import { analysePositions, convertPositionResult, parseEngines, resultToStoredEval } from "./response.js";
+import { resolveFromNodeOrFen, storeEvals } from "./file_handle.js";
 const deepJobs = new Map();
 const DEEP_JOB_TTL_MS = 15 * 60 * 1000;
 function newDeepJobId() {
@@ -33,57 +22,43 @@ function reapExpiredDeepJobs() {
 }
 export async function deepAnalyseStart(args) {
     reapExpiredDeepJobs();
+    const [engine] = parseEngines(args.engine, ["stockfish"]);
     const resolved = await resolveFromNodeOrFen(args);
     const fen = resolved.fen;
     const movetimeMs = typeof args.movetime_ms === "number" ? args.movetime_ms : 60_000;
-    // Default 2 — SF loses meaningful strength at higher multipv, so a
-    // deep think is best spent on a tight candidate list. Matches the
-    // cloud_analyse stockfish_multipv default.
-    const multipv = typeof args.multipv === "number" ? args.multipv : 2;
+    // Default 2 for Stockfish (it loses strength at higher multipv), 8 for
+    // the NN engines (it costs them nothing).
+    const multipv = typeof args.multipv === "number" ? args.multipv : engine === "stockfish" ? 2 : 8;
+    const opts = { engines: [engine], movetime_ms: movetimeMs, multipv: { [engine]: multipv } };
+    if (typeof args.contempt === "number")
+        opts.contempt = args.contempt;
+    if (typeof args.rental === "string" && args.rental.trim())
+        opts.rentals = { [engine]: args.rental.trim() };
     const jobId = newDeepJobId();
     const job = {
         id: jobId,
-        routing: analyseRouting(args),
+        engine,
+        opts,
         status: "running",
         fileHandle: resolved.file,
         fen,
         movetimeMs,
-        multipv,
         startedAt: Date.now(),
         cancelController: new AbortController(),
     };
     deepJobs.set(jobId, job);
-    // Kick off the long HTTP call unawaited — resolves when the backend
-    // returns the SF snapshot. authedRequest is a plain fetch under the
-    // hood; abort signal flows via cancelController.
     void runDeepJob(job).catch(err => {
         job.status = "error";
         job.error = err instanceof Error ? err.message : String(err);
         job.finishedAt = Date.now();
     });
-    return {
-        job_id: jobId,
-        status: "running",
-        movetime_ms: movetimeMs,
-        fen,
-    };
+    return { job_id: jobId, status: "running", engine, movetime_ms: movetimeMs, fen };
 }
 async function runDeepJob(job) {
-    const body = {
-        fen: job.fen,
-        movetime_ms: job.movetimeMs,
-        stockfish_multipv: job.multipv,
-        engines: ["stockfish"],
-        ...job.routing,
-    };
     let raw;
     try {
-        // TODO(future): plumb an AbortSignal through authedRequest for
-        // real mid-flight cancellation. For now, cancel just marks the
-        // job so the caller stops polling; the backend still runs the
-        // engine to completion and the result is stored on the job
-        // record but flagged cancelled.
-        raw = await authedRequest("POST", "/api/agent/cloud-engines/analyse", body);
+        // Cancel only marks the job; the backend runs the think to completion.
+        [raw] = await analysePositions([{ fen: job.fen }], job.opts);
     }
     catch (err) {
         job.status = "error";
@@ -91,31 +66,26 @@ async function runDeepJob(job) {
         job.finishedAt = Date.now();
         return;
     }
-    const converted = convertCloudSnapshotResponse(raw, job.fen);
-    const sf = converted.stockfish;
-    if (job.cancelController.signal.aborted) {
-        job.status = "cancelled";
-    }
-    else {
-        job.status = "done";
-    }
-    job.result = sf ?? null;
-    job.finishedAt = Date.now();
-    // Same node-persistence as cloud_analyse: if the caller anchored on
-    // file_id+node_id, store the SF-only eval as the node's ceoEval so
-    // quote_engine_eval can cite it later. We build a StoredEval that has
-    // only the sf leg — no Lc0 was run.
-    if (job.fileHandle && sf) {
-        const ev = analysisToStoredEval({ stockfish: sf });
+    const converted = raw ? convertPositionResult(raw) : undefined;
+    const block = converted?.engines[job.engine];
+    job.result = block ?? null;
+    if (block?.error)
+        job.error = block.error;
+    // Merge into the node's ceoEval (other engines' stored reads are kept)
+    // and stamp transpositions, same as cloud_analyse.
+    if (job.fileHandle && converted && !job.cancelController.signal.aborted) {
+        const ev = resultToStoredEval(converted);
         if (ev) {
             try {
-                await storeEvalOnNode(job.fileHandle, ev);
+                [job.storedOn] = await storeEvals(job.fileHandle.id, [{ fen: job.fen, ev }]);
             }
-            catch {
-                // best-effort — the analysis result is what the LLM asked for
+            catch (err) {
+                job.storeError = `analysis done but saving to the file failed: ${err instanceof Error ? err.message : String(err)}`;
             }
         }
     }
+    job.status = job.cancelController.signal.aborted ? "cancelled" : block && !block.error ? "done" : "error";
+    job.finishedAt = Date.now();
 }
 export function deepAnalyseStatus(args) {
     reapExpiredDeepJobs();
@@ -134,8 +104,11 @@ export function deepAnalyseStatus(args) {
         status: job.status,
         movetime_ms: job.movetimeMs,
         elapsed_ms: (job.finishedAt ?? Date.now()) - job.startedAt,
+        engine: job.engine,
         fen: job.fen,
         result: job.result,
+        stored_on: job.storedOn,
+        store_error: job.storeError,
         error: job.error,
         started_at_ms: job.startedAt,
         finished_at_ms: job.finishedAt,

package/dist/analysis/file_handle.js

@@ -120,48 +120,55 @@ export function getNodeByPath(root, path) {
     }
     return cur;
 }
-// Persist a fresh ceoEval on the node referenced by the file handle
-// AND on every other node in the same file that transposes to the
-// same position (matches on the frontend's 3-field FEN key: piece
-// placement + side to move + castling). Best-effort — if the file
-// version raced (another agent saved between our GET and our PUT),
-// we silently drop the store rather than fail the analysis the LLM
-// actually asked for. The eval is still returned in the response
-// either way.
+// Merge fresh evals into a file and save once. Each entry is stamped on
+// every node that reaches its position (the frontend's 3-field FEN key:
+// piece placement + side to move + castling), so a transposition is never
+// analysed twice. Merging per engine means a Stockfish-only result keeps a
+// stored human or Lc0 read.
 //
-// Return: ids of every node the eval was stamped on (empty on error).
-// The primary node's id is always first (if present).
+// The file is re-read right before the write, and a version race (someone
+// saved between our GET and PUT) is retried once on a fresh copy; the merge
+// makes re-applying safe. Returns, per entry, the ids it was stamped on
+// (empty if that position is not in the file). Throws if the save fails
+// twice, so callers can report it rather than silently lose evals.
+export async function storeEvals(fileId, entries) {
+    let lastErr;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const g = await fetchGame(fileId);
+        const parsed = parsePGN(g.pgnContent);
+        const fenIndex = buildFenIndex(parsed.root);
+        const idIndex = buildIdIndex(parsed.root);
+        let file = parsed;
+        const stamped = [];
+        for (const { fen, ev } of entries) {
+            const group = fenIndex.get(positionKey(fen)) ?? [];
+            const paths = group.map(n => resolveNodeId(idIndex, n.id));
+            const step = setCeoEvalMany(file, paths, ev);
+            file = step.file;
+            stamped.push(step.ids);
+        }
+        if (stamped.every(ids => ids.length === 0))
+            return stamped;
+        try {
+            await saveGame(fileId, exportPGN(file), g.version ?? 0);
+            return stamped;
+        }
+        catch (err) {
+            lastErr = err;
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+// Single-node wrapper: stamp `ev` on the handle's node and its transpositions.
+// Returns the ids, the addressed node first; empty on failure (the analysis
+// result is still returned to the caller either way).
 export async function storeEvalOnNode(handle, ev) {
     try {
         const anchor = getNodeByPath(handle.parsedFile.root, handle.nodePath);
-        const key = positionKey(anchor.fen);
-        const fenIndex = buildFenIndex(handle.parsedFile.root);
-        const group = fenIndex.get(key) ?? [anchor];
-        // Resolve every transposed node back to its path. cloneOnPath
-        // rebuilds the spine so we need paths, not references — the
-        // id index was built against the original tree and every id in
-        // `group` exists there.
-        const idIndex = handle.idIndex ?? buildIdIndex(handle.parsedFile.root);
-        const paths = group.map(n => resolveNodeId(idIndex, n.id));
-        const { file: newFile, ids } = setCeoEvalMany(handle.parsedFile, paths, ev);
-        const newPgn = exportPGN(newFile);
-        await saveGame(handle.id, newPgn, handle.version);
-        // Ensure the primary node (the one the LLM addressed) comes first.
-        const anchorId = anchor.id;
-        return [anchorId, ...ids.filter(x => x !== anchorId)];
+        const [ids] = await storeEvals(handle.id, [{ fen: anchor.fen, ev }]);
+        return [anchor.id, ...(ids ?? []).filter(x => x !== anchor.id)];
     }
     catch {
         return [];
     }
 }
-// Routing fields for POST /api/agent/cloud-engines/analyse: which rental to
-// run on and which engine legs to run. Omitted fields let the backend pick.
-export function analyseRouting(args) {
-    const out = {};
-    if (typeof args.contract_id === "string" && args.contract_id.trim()) {
-        out.contract_id = args.contract_id.trim();
-    }
-    if (Array.isArray(args.engines))
-        out.engines = args.engines;
-    return out;
-}

package/dist/analysis/response.js

@@ -1,18 +1,96 @@
-// Shared engine-response helpers used across cloud_analyse, auto_evaluate,
-// deep_analyse, and get_position_stats. All PGN-shape data comes back
-// from the backend in UCI ("g1f3") — this module converts to SAN, extracts
-// stored evals from the raw JSON, and derives the eval → NAG mapping.
-//
-// Extracted from src/index.ts in v0.44 as part of the file split.
+// Shared engine helpers for cloud_analyse, auto_evaluate, deep_analyse and
+// the compact eval attached to position tools. The backend returns one
+// result per position with a block per engine (stockfish, lc0, human), PVs
+// in UCI and WDL in per mille. This module calls it in chunks, converts PVs
+// to SAN and WDL to percent, and turns a result into the stored ceoEval.
 import { Chess } from "chess.js";
 import { authedRequest } from "../http.js";
-// Convert a UCI move sequence into SAN by walking it move-by-move on
-// chess.js from the given starting FEN. LLMs reason far better in SAN
-// ("Nf3", "Bxc4") than UCI ("g1f3", "b5c4"), and matches how prep
-// discussion is written in the real world. If a move fails to parse
-// (illegal from the current position — bug or truncated PV), we
-// truncate cleanly rather than throwing so the response still carries
-// what we could convert.
+export const ENGINES = ["stockfish", "lc0", "human"];
+// Engine name → key in the stored ceoEval / [%ceo-eval] escape.
+export const STORED_KEY = { stockfish: "sf", lc0: "lc0", human: "human" };
+// Backend limits (handlers/agent.go): positions per call, and positions ×
+// movetime per call. analysePositions chunks to stay inside both.
+export const MAX_POSITIONS_PER_CALL = 10;
+const MAX_CALL_BUDGET_MS = 150_000;
+export const DEFAULT_MOVETIME_MS = 2000;
+// Validate an `engines` argument. Unknown names throw (better than silently
+// running fewer engines than the caller asked for).
+export function parseEngines(v, fallback) {
+    if (v === undefined || v === null)
+        return fallback;
+    const list = Array.isArray(v) ? v : [v];
+    const out = [];
+    for (const e of list) {
+        const name = String(e).trim().toLowerCase();
+        if (!ENGINES.includes(name)) {
+            throw new Error(`unknown engine '${e}' (allowed: stockfish, lc0, human)`);
+        }
+        if (!out.includes(name))
+            out.push(name);
+    }
+    if (out.length === 0)
+        throw new Error("engines must list at least one of: stockfish, lc0, human");
+    return out;
+}
+// Pull the optional per-engine knobs (multipv, contempt, rentals) out of tool
+// args. Shared by every analysis tool so they all accept the same shape.
+export function analyseOptionsFromArgs(args, engines, movetimeMs) {
+    const opts = { engines, movetime_ms: movetimeMs };
+    const pickMap = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : undefined;
+    const mpv = pickMap(args.multipv);
+    if (mpv) {
+        const out = {};
+        for (const e of ENGINES)
+            if (typeof mpv[e] === "number")
+                out[e] = mpv[e];
+        opts.multipv = out;
+    }
+    if (typeof args.contempt === "number")
+        opts.contempt = args.contempt;
+    const rentals = pickMap(args.rentals);
+    if (rentals) {
+        const out = {};
+        for (const e of ENGINES)
+            if (typeof rentals[e] === "string" && rentals[e].trim())
+                out[e] = rentals[e].trim();
+        opts.rentals = out;
+    }
+    return opts;
+}
+// Run positions through the backend, chunked to its per-call limits. Results
+// come back in input order, raw (UCI PVs, per-mille WDL).
+export async function analysePositions(positions, opts) {
+    const movetime = opts.movetime_ms ?? DEFAULT_MOVETIME_MS;
+    const perCall = Math.max(1, Math.min(MAX_POSITIONS_PER_CALL, Math.floor(MAX_CALL_BUDGET_MS / movetime)));
+    // Every position gets an id; results are matched back by id, not order.
+    const withIds = positions.map((p, i) => ({ id: p.id ?? `p${i + 1}`, fen: p.fen }));
+    const byId = new Map();
+    for (let i = 0; i < withIds.length; i += perCall) {
+        const body = {
+            positions: withIds.slice(i, i + perCall),
+            engines: opts.engines,
+            movetime_ms: movetime,
+        };
+        if (opts.multipv && Object.keys(opts.multipv).length > 0)
+            body.multipv = opts.multipv;
+        if (typeof opts.contempt === "number")
+            body.contempt = opts.contempt;
+        if (opts.rentals && Object.keys(opts.rentals).length > 0)
+            body.rentals = opts.rentals;
+        const raw = (await authedRequest("POST", "/api/agent/cloud-engines/analyse", body));
+        if (!raw || !Array.isArray(raw.positions))
+            throw new Error("unexpected response from the analyse endpoint");
+        for (const r of raw.positions)
+            if (r && typeof r.id === "string")
+                byId.set(r.id, r);
+    }
+    // A position the backend didn't answer comes back with no engines, so
+    // callers report it as failed rather than shifting other results.
+    return withIds.map(p => byId.get(p.id) ?? { id: p.id, fen: p.fen, engines: {} });
+}
+// Convert a UCI move sequence into SAN by walking it on chess.js from the
+// given FEN. LLMs reason far better in SAN. If a move fails to parse
+// (truncated PV), stop cleanly rather than throw.
 export function uciLineToSAN(startFen, uciMoves) {
     const board = new Chess(startFen);
     const out = [];
@@ -51,131 +129,105 @@ export function uciMoveToSAN(startFen, uci) {
         return uci;
     }
 }
-// Fetch a compact cloud eval for `fen`. Returns null on any error — no
-// running combo instance, engine failure, network timeout. Callers
-// attach the result to their response as `.eval` so the LLM has the
-// stockfish + lc0 read without a separate tool call.
-export async function fetchCompactEval(fen) {
-    try {
-        const raw = await authedRequest("POST", "/api/agent/cloud-engines/analyse", { fen, movetime_ms: 1500, multipv: 1 });
-        const converted = convertCloudSnapshotResponse(raw, fen);
-        const stored = analysisToStoredEval(converted);
-        return storedEvalToCompact(stored, converted);
-    }
-    catch {
-        return null;
-    }
-}
-// Trim every PV in a converted cloud-analyse response to `maxPlies`
-// and mark each trimmed line with `pv_truncated: true` so the LLM
-// sees what happened. Applied ONLY to cloud_analyse (short synchronous
-// snapshot); deep_analyse is the explicit "give me the deep line"
-// tool and keeps its full PV.
-export function capPvsInResponse(converted, maxPlies) {
-    if (!converted || typeof converted !== "object")
-        return;
-    const r = converted;
-    for (const eng of [r.stockfish, r.lc0]) {
-        if (!eng || !Array.isArray(eng.lines))
+// In place: PVs and bestMove to SAN, WDL from per mille to percent, and (if
+// pvMaxPlies is set) PVs capped with `pv_truncated` on trimmed lines. PVs
+// past ~6 plies are speculative, and long ones get pasted into add_line as
+// if they were prep; the caller re-analyses the end position to see more.
+export function convertPositionResult(r, pvMaxPlies) {
+    for (const e of ENGINES) {
+        const block = r.engines?.[e];
+        if (!block)
             continue;
-        for (const line of eng.lines) {
-            if (Array.isArray(line.pv) && line.pv.length > maxPlies) {
-                line.pv = line.pv.slice(0, maxPlies);
-                line.pv_truncated = true;
+        for (const line of block.lines ?? []) {
+            if (Array.isArray(line.pv)) {
+                line.pv = uciLineToSAN(r.fen, line.pv);
+                if (pvMaxPlies && line.pv.length > pvMaxPlies) {
+                    line.pv = line.pv.slice(0, pvMaxPlies);
+                    line.pv_truncated = true;
+                }
             }
+            if (line.wdl)
+                line.wdl = wdlPercent(line.wdl);
         }
+        if (typeof block.bestMove === "string")
+            block.bestMove = uciMoveToSAN(r.fen, block.bestMove);
     }
-    converted.pv_max_plies = maxPlies;
+    return r;
 }
-export function convertCloudSnapshotResponse(raw, startFen) {
-    if (!raw || typeof raw !== "object")
-        return raw;
-    const r = raw;
-    for (const eng of [r.stockfish, r.lc0]) {
-        if (!eng)
-            continue;
-        if (Array.isArray(eng.lines)) {
-            for (const line of eng.lines) {
-                if (Array.isArray(line.pv))
-                    line.pv = uciLineToSAN(startFen, line.pv);
-            }
-        }
-        if (typeof eng.bestMove === "string")
-            eng.bestMove = uciMoveToSAN(startFen, eng.bestMove);
+// Per mille → whole percent summing to 100 (largest remainder), so a
+// stored W/D/L never reads 101%.
+function wdlPercent(m) {
+    const total = m.w + m.d + m.l || 1;
+    const exact = [m.w, m.d, m.l].map(v => (v * 100) / total);
+    const floor = exact.map(Math.floor);
+    let left = 100 - floor.reduce((a, b) => a + b, 0);
+    const order = exact.map((v, i) => [v - floor[i], i]).sort((a, b) => b[0] - a[0]);
+    for (const [, i] of order) {
+        if (left <= 0)
+            break;
+        floor[i]++;
+        left--;
     }
-    return raw;
+    return { w: floor[0], d: floor[1], l: floor[2] };
 }
-export function analysisToStoredEval(analysis) {
-    if (!analysis || typeof analysis !== "object")
-        return null;
-    const r = analysis;
-    // Backend returns White-POV cp/mate (engine-ws flips in ParseInfo
-    // based on side-to-move, cloud_snapshot passes through). Pure
-    // pass-through here — a previous sign-flip on black-to-move was
-    // wrong and silently inverted every Black-to-move stored eval.
-    const engineEval = (block) => {
-        const line = block?.lines?.[0];
-        if (!line)
-            return undefined;
-        const depth = line.depth ?? block?.depth;
-        if (typeof line.mate === "number")
-            return { mate: line.mate, depth };
-        if (typeof line.scoreCp === "number")
-            return { cp: line.scoreCp, depth };
-        return undefined;
-    };
-    const sf = engineEval(r.stockfish);
-    const lc0 = engineEval(r.lc0);
-    if (!sf && !lc0)
-        return null;
+// Stored eval from a CONVERTED result (WDL already in percent). Stockfish
+// stores cp/mate; lc0 and human store WDL, falling back to cp/mate if an
+// engine sent no WDL. Engines that errored or returned no line are left out,
+// so a merge keeps whatever was stored for them before.
+export function resultToStoredEval(r) {
     const ev = {};
-    if (sf)
-        ev.sf = sf;
-    if (lc0)
-        ev.lc0 = lc0;
-    ev.nag = nagFromCp(sf?.cp, sf?.mate) ?? nagFromCp(lc0?.cp, lc0?.mate) ?? undefined;
-    return ev;
+    for (const e of ENGINES) {
+        const block = r.engines?.[e];
+        const line = block?.lines?.[0];
+        if (!block || block.error || !line)
+            continue;
+        const depth = line.depth ?? block.depth;
+        let stored;
+        if (e !== "stockfish" && line.wdl) {
+            stored = { w: line.wdl.w, d: line.wdl.d, l: line.wdl.l, depth };
+        }
+        else if (typeof line.mate === "number") {
+            stored = { mate: line.mate, depth };
+        }
+        else if (typeof line.scoreCp === "number") {
+            stored = { cp: line.scoreCp, depth };
+        }
+        if (stored)
+            ev[STORED_KEY[e]] = stored;
+    }
+    return ev.sf || ev.lc0 || ev.human ? ev : null;
 }
-export function nagFromCp(cp, mate) {
-    let effective;
-    if (typeof mate === "number")
-        effective = mate > 0 ? 10000 : -10000;
-    else if (typeof cp === "number")
-        effective = cp;
-    else
-        return null;
-    const abs = Math.abs(effective);
-    if (abs < 25)
-        return "$10";
-    if (abs < 60)
-        return effective > 0 ? "$14" : "$15";
-    if (abs < 130)
-        return effective > 0 ? "$16" : "$17";
-    return effective > 0 ? "$18" : "$19";
+// Engines that produced no usable line for this position, with the reason.
+export function engineFailures(r, engines) {
+    const out = {};
+    for (const e of engines) {
+        const block = r.engines?.[e];
+        if (!block)
+            out[e] = "no result";
+        else if (block.error)
+            out[e] = block.error;
+        else if (!block.lines || block.lines.length === 0)
+            out[e] = "no lines";
+    }
+    return out;
 }
-// Adapter for the compact eval attached to live query responses. Same
-// derivation logic; different output shape (needs the .nag + summary
-// used by get_position_stats / prep_snapshot).
-export function storedEvalToCompact(ev, analysis) {
-    if (!ev)
-        return null;
-    const a = analysis;
-    const compact = { nag: ev.nag ?? null };
-    if (ev.sf) {
-        compact.stockfish = {
-            cp: ev.sf.cp,
-            mate: ev.sf.mate,
-            bestMove: a.stockfish?.bestMove,
-            pv: a.stockfish?.lines?.[0]?.pv,
-        };
+export async function fetchCompactEval(fen) {
+    try {
+        const [raw] = await analysePositions([{ fen }], {
+            engines: ["stockfish"],
+            movetime_ms: 1500,
+            multipv: { stockfish: 1 },
+        });
+        if (!raw)
+            return null;
+        const r = convertPositionResult(raw, 6);
+        const sf = r.engines.stockfish;
+        const line = sf?.lines?.[0];
+        if (!sf || sf.error || !line)
+            return null;
+        return { stockfish: { cp: line.scoreCp, mate: line.mate, bestMove: sf.bestMove, pv: line.pv } };
     }
-    if (ev.lc0) {
-        compact.lc0 = {
-            cp: ev.lc0.cp,
-            mate: ev.lc0.mate,
-            bestMove: a.lc0?.bestMove,
-            pv: a.lc0?.lines?.[0]?.pv,
-        };
+    catch {
+        return null;
     }
-    return compact;
 }