wyrm-mcp 7.3.2 → 7.3.3

package/dist/replication-daemon.js

@@ -1,2 +1,262 @@
-import{spawn as b}from"child_process";import{existsSync as h,readFileSync as j,writeFileSync as M,statSync as I,mkdirSync as _,openSync as N,closeSync as w,unlinkSync as k,renameSync as U}from"fs";import{homedir as T}from"os";import{join as m}from"path";import{replicateOnce as A}from"./event-replication.js";import{checkPeerUrl as R,isValidTokenEnvName as g}from"./repl-guard.js";const l=m(T(),".wyrm"),p=m(l,"wyrm-replication.pid"),c=m(l,"wyrm-replication.log"),E=6e4,v=5e3,x=1e6,L=0,u="repl:peers",S=50;function $(r){if(!r||typeof r.baseUrl!="string")return{ok:!1,reason:"baseUrl required"};const e=R(i(r.baseUrl));return!e.ok&&!/loopback|private|link-local/.test(e.reason)?{ok:!1,reason:e.reason}:!r.projectPath||typeof r.projectPath!="string"?{ok:!1,reason:"projectPath required"}:r.tokenEnv&&!g(r.tokenEnv)?{ok:!1,reason:`tokenEnv must be a WYRM_-prefixed env var name (got ${r.tokenEnv})`}:{ok:!0}}const i=r=>String(r).replace(/\/+$/,"");function d(r){try{const e=r.getMeta(u),n=e?JSON.parse(e):[];return Array.isArray(n)?n:[]}catch{return[]}}function B(r,e){const n=$(e);if(!n.ok)throw new Error(n.reason||"invalid peer");const s={baseUrl:i(e.baseUrl),projectPath:e.projectPath,...e.remoteProject?{remoteProject:e.remoteProject}:{},...e.tokenEnv?{tokenEnv:e.tokenEnv}:{}},t=d(r).filter(o=>!(i(o.baseUrl)===s.baseUrl&&o.projectPath===s.projectPath));return t.push(s),t.length>S&&t.splice(0,t.length-S),r.setMeta(u,JSON.stringify(t)),t}function W(r,e,n){const s=i(e),t=d(r).filter(o=>!(i(o.baseUrl)===s&&o.projectPath===n));return r.setMeta(u,JSON.stringify(t)),t}class q{db;intervalMs;constructor(e,n=E){this.db=e,this.intervalMs=n,P(),this.intervalMs=Math.max(v,n)}async tick(e=globalThis.fetch){if(!this.db.liveMemoryEnabled())return[];const n=d(this.db),s=[];for(const t of n){const o=this.db.getProject(t.projectPath);if(!o){s.push({peer:t.baseUrl,errors:["project not found: "+t.projectPath]});continue}const y=t.tokenEnv&&g(t.tokenEnv)?process.env[t.tokenEnv]:void 0;try{const a=await A(this.db,{baseUrl:i(t.baseUrl),token:y,localProjectId:o.id,remoteProject:t.remoteProject||o.name},e);s.push({peer:t.baseUrl,project:o.name,...a})}catch(a){s.push({peer:t.baseUrl,project:o.name,errors:[a instanceof Error?a.message:String(a)]})}}return s}async run(){f(`replication daemon started \xB7 interval=${this.intervalMs}ms \xB7 peers=${d(this.db).length}`);let e=!1;const n=setInterval(async()=>{if(!e){e=!0;try{const t=await this.tick();for(const o of t)(o.errors.length||(o.pulled||0)+(o.pushed||0)>0)&&f(`tick: ${JSON.stringify(o)}`)}catch(t){f(`tick error: ${t instanceof Error?t.message:String(t)}`)}finally{e=!1}}},this.intervalMs),s=t=>{clearInterval(n),f(`${t} \u2014 shutting down`);try{this.db.close?.()}catch{}process.exit(0)};process.on("SIGTERM",()=>s("SIGTERM")),process.on("SIGINT",()=>s("SIGINT"))}}class z{daemonEntrypoint;constructor(e){this.daemonEntrypoint=e,P()}start(e={}){if(this.isAlive())return{ok:!1,pid:this.readPid(),reason:"already running"};F();const n=Number(e.interval_minutes),s=Number.isFinite(n)&&n>0?Math.round(n*6e4):E,t=N(c,"a");try{const o=b(process.execPath,[this.daemonEntrypoint,String(s)],{detached:!0,stdio:["ignore",t,t],env:{...process.env}});return o.unref(),typeof o.pid!="number"?{ok:!1,reason:"spawn returned no pid"}:(M(p,String(o.pid)),{ok:!0,pid:o.pid})}finally{w(t)}}stop(){if(!this.isAlive())return this.cleanPid(),{ok:!1,reason:"not running"};const e=this.readPid();if(!e)return{ok:!1,reason:"pid file unreadable"};try{return process.kill(e,"SIGTERM"),{ok:!0}}catch(n){return{ok:!1,reason:n instanceof Error?n.message:String(n)}}}status(){const e=this.isAlive();return{running:e,pid:e?this.readPid()??void 0:void 0}}isAlive(){if(!h(p))return!1;const e=this.readPid();if(!e)return!1;try{return process.kill(e,L),!0}catch{return!1}}readPid(){try{const e=Number(j(p,"utf8").trim());return Number.isFinite(e)&&e>0?e:void 0}catch{return}}cleanPid(){try{k(p)}catch{}}}function P(){h(l)||_(l,{recursive:!0})}function f(r){process.stdout.write(`[${new Date().toISOString()}] ${r}
-`)}function F(){if(h(c))try{if(I(c).size>x){const r=`${c}.1`;try{k(r)}catch{}U(c,r)}}catch{}}export{E as DEFAULT_INTERVAL_MS,v as MIN_INTERVAL_MS,u as PEERS_META_KEY,q as ReplicationDaemon,z as ReplicationManager,B as addPeer,d as listPeers,W as removePeer,$ as validatePeerEntry};
+/**
+ * Wyrm Live Memory v6.4 (Phase 3b) — always-on replication daemon.
+ *
+ * Wraps the Phase-3 `replicateOnce` primitive in a background loop that syncs a
+ * registry of peers on an interval. Mirrors the `CloudSyncDaemon` /
+ * `CloudSyncManager` shape (detached child + PID file + liveness + rotating log).
+ *
+ * Secret hygiene: a peer's bearer token is NEVER stored in the DB. The registry
+ * holds the NAME of an env var (`tokenEnv`); the token is resolved from
+ * `process.env` at tick time, so the SQLite file never contains a credential.
+ *
+ * The daemon shares the MCP server's DB (`~/.wyrm/wyrm.db` by default, or
+ * `WYRM_DB_PATH`) — better-sqlite3 WAL supports the concurrent connections.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, statSync, mkdirSync, openSync, closeSync, unlinkSync, renameSync, } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { replicateOnce } from './event-replication.js';
+import { checkPeerUrl, isValidTokenEnvName } from './repl-guard.js';
+const WYRM_DIR = join(homedir(), '.wyrm');
+const PID_FILE = join(WYRM_DIR, 'wyrm-replication.pid');
+const LOG_FILE = join(WYRM_DIR, 'wyrm-replication.log');
+const DEFAULT_INTERVAL_MS = 60_000; // 1 min — events are small + incremental
+const MIN_INTERVAL_MS = 5_000; // floor: don't hammer a peer
+const LOG_ROTATE_BYTES = 1_000_000; // 1 MB
+const LIVENESS_SIGNAL = 0;
+const PEERS_META_KEY = 'repl:peers';
+const MAX_PEERS = 50;
+/** Validate a peer entry at registration time (scheme/URL + tokenEnv name). */
+export function validatePeerEntry(entry) {
+    if (!entry || typeof entry.baseUrl !== 'string')
+        return { ok: false, reason: 'baseUrl required' };
+    const url = checkPeerUrl(cleanBase(entry.baseUrl));
+    // Registration is lenient on private hosts (the egress guard re-checks at fetch
+    // time); only reject an unparseable URL or a bad scheme here.
+    if (!url.ok && !/loopback|private|link-local/.test(url.reason))
+        return { ok: false, reason: url.reason };
+    if (!entry.projectPath || typeof entry.projectPath !== 'string')
+        return { ok: false, reason: 'projectPath required' };
+    if (entry.tokenEnv && !isValidTokenEnvName(entry.tokenEnv)) {
+        return { ok: false, reason: `tokenEnv must be a WYRM_-prefixed env var name (got ${entry.tokenEnv})` };
+    }
+    return { ok: true };
+}
+// ==================== REGISTRY ====================
+const cleanBase = (u) => String(u).replace(/\/+$/, '');
+/** Read the persisted peer registry (tolerant of corruption — returns []). */
+export function listPeers(db) {
+    try {
+        const raw = db.getMeta(PEERS_META_KEY);
+        const parsed = raw ? JSON.parse(raw) : [];
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Upsert a peer (keyed on baseUrl + projectPath). Throws on an invalid entry. Returns the new registry. */
+export function addPeer(db, entry) {
+    const v = validatePeerEntry(entry);
+    if (!v.ok)
+        throw new Error(v.reason || 'invalid peer');
+    const e = {
+        baseUrl: cleanBase(entry.baseUrl),
+        projectPath: entry.projectPath,
+        ...(entry.remoteProject ? { remoteProject: entry.remoteProject } : {}),
+        ...(entry.tokenEnv ? { tokenEnv: entry.tokenEnv } : {}),
+    };
+    const peers = listPeers(db).filter((p) => !(cleanBase(p.baseUrl) === e.baseUrl && p.projectPath === e.projectPath));
+    peers.push(e);
+    if (peers.length > MAX_PEERS)
+        peers.splice(0, peers.length - MAX_PEERS);
+    db.setMeta(PEERS_META_KEY, JSON.stringify(peers));
+    return peers;
+}
+/** Remove a peer by baseUrl + projectPath. Returns the new registry. */
+export function removePeer(db, baseUrl, projectPath) {
+    const target = cleanBase(baseUrl);
+    const peers = listPeers(db).filter((p) => !(cleanBase(p.baseUrl) === target && p.projectPath === projectPath));
+    db.setMeta(PEERS_META_KEY, JSON.stringify(peers));
+    return peers;
+}
+// ==================== DAEMON ====================
+export class ReplicationDaemon {
+    db;
+    intervalMs;
+    constructor(db, intervalMs = DEFAULT_INTERVAL_MS) {
+        this.db = db;
+        this.intervalMs = intervalMs;
+        ensureWyrmDir();
+        this.intervalMs = Math.max(MIN_INTERVAL_MS, intervalMs);
+    }
+    /** Run one replication round over all registered peers. Never throws. */
+    async tick(fetchImpl = globalThis.fetch) {
+        if (!this.db.liveMemoryEnabled())
+            return [];
+        const peers = listPeers(this.db);
+        const results = [];
+        for (const p of peers) {
+            const project = this.db.getProject(p.projectPath);
+            if (!project) {
+                results.push({ peer: p.baseUrl, errors: ['project not found: ' + p.projectPath] });
+                continue;
+            }
+            // Resolve the token only from a validly-named env var (never an arbitrary process secret).
+            const token = p.tokenEnv && isValidTokenEnvName(p.tokenEnv) ? process.env[p.tokenEnv] : undefined;
+            try {
+                const r = await replicateOnce(this.db, { baseUrl: cleanBase(p.baseUrl), token, localProjectId: project.id, remoteProject: p.remoteProject || project.name }, fetchImpl);
+                results.push({ peer: p.baseUrl, project: project.name, ...r });
+            }
+            catch (err) {
+                results.push({ peer: p.baseUrl, project: project.name, errors: [err instanceof Error ? err.message : String(err)] });
+            }
+        }
+        return results;
+    }
+    /** Long-running loop. Spawned detached; logs to stdout (redirected to LOG_FILE). */
+    async run() {
+        log(`replication daemon started · interval=${this.intervalMs}ms · peers=${listPeers(this.db).length}`);
+        let inFlight = false;
+        const timer = setInterval(async () => {
+            if (inFlight)
+                return; // never overlap ticks
+            inFlight = true;
+            try {
+                const results = await this.tick();
+                for (const r of results) {
+                    if (r.errors.length || (r.pulled || 0) + (r.pushed || 0) > 0) {
+                        log(`tick: ${JSON.stringify(r)}`);
+                    }
+                }
+            }
+            catch (e) {
+                log(`tick error: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            finally {
+                inFlight = false;
+            }
+        }, this.intervalMs);
+        const shutdown = (signal) => {
+            clearInterval(timer);
+            log(`${signal} — shutting down`);
+            try {
+                this.db.close?.();
+            }
+            catch { /* best-effort WAL checkpoint + close */ }
+            process.exit(0);
+        };
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        process.on('SIGINT', () => shutdown('SIGINT'));
+    }
+}
+// ==================== MANAGER ====================
+export class ReplicationManager {
+    daemonEntrypoint;
+    constructor(daemonEntrypoint) {
+        this.daemonEntrypoint = daemonEntrypoint;
+        ensureWyrmDir();
+    }
+    start(opts = {}) {
+        if (this.isAlive())
+            return { ok: false, pid: this.readPid(), reason: 'already running' };
+        rotateLogIfBig();
+        const mins = Number(opts.interval_minutes);
+        const intervalMs = Number.isFinite(mins) && mins > 0 ? Math.round(mins * 60_000) : DEFAULT_INTERVAL_MS;
+        // One shared fd for both stdout+stderr; try/finally so a spawn throw can't leak it.
+        const logFd = openSync(LOG_FILE, 'a');
+        try {
+            const child = spawn(process.execPath, [this.daemonEntrypoint, String(intervalMs)], {
+                detached: true,
+                stdio: ['ignore', logFd, logFd],
+                env: { ...process.env },
+            });
+            child.unref();
+            if (typeof child.pid !== 'number')
+                return { ok: false, reason: 'spawn returned no pid' };
+            writeFileSync(PID_FILE, String(child.pid));
+            return { ok: true, pid: child.pid };
+        }
+        finally {
+            closeSync(logFd);
+        }
+    }
+    stop() {
+        if (!this.isAlive()) {
+            this.cleanPid();
+            return { ok: false, reason: 'not running' };
+        }
+        const pid = this.readPid();
+        if (!pid)
+            return { ok: false, reason: 'pid file unreadable' };
+        try {
+            process.kill(pid, 'SIGTERM');
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, reason: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    status() {
+        const running = this.isAlive();
+        return { running, pid: running ? this.readPid() ?? undefined : undefined };
+    }
+    isAlive() {
+        if (!existsSync(PID_FILE))
+            return false;
+        const pid = this.readPid();
+        if (!pid)
+            return false;
+        try {
+            process.kill(pid, LIVENESS_SIGNAL);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    readPid() {
+        try {
+            const n = Number(readFileSync(PID_FILE, 'utf8').trim());
+            return Number.isFinite(n) && n > 0 ? n : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    cleanPid() {
+        try {
+            unlinkSync(PID_FILE);
+        }
+        catch { /* idempotent */ }
+    }
+}
+// ==================== HELPERS ====================
+function ensureWyrmDir() {
+    if (!existsSync(WYRM_DIR))
+        mkdirSync(WYRM_DIR, { recursive: true });
+}
+function log(msg) {
+    process.stdout.write(`[${new Date().toISOString()}] ${msg}\n`);
+}
+function rotateLogIfBig() {
+    if (!existsSync(LOG_FILE))
+        return;
+    try {
+        if (statSync(LOG_FILE).size > LOG_ROTATE_BYTES) {
+            const rotated = `${LOG_FILE}.1`;
+            try {
+                unlinkSync(rotated);
+            }
+            catch { /* ignore */ }
+            renameSync(LOG_FILE, rotated);
+        }
+    }
+    catch { /* non-fatal */ }
+}
+export { DEFAULT_INTERVAL_MS, MIN_INTERVAL_MS, PEERS_META_KEY };
+//# sourceMappingURL=replication-daemon.js.map

package/dist/rerank.js

@@ -1 +1,142 @@
-const E=5,h=500,M="http://localhost:8088";function T(){return!!(process.env.WYRM_RERANK_MODEL&&process.env.WYRM_RERANK_MODEL.trim())}function m(){const t=Number(process.env.WYRM_RERANK_TIMEOUT);return Number.isFinite(t)&&t>0?t:500}function p(){return((process.env.WYRM_RERANK_URL||"").trim()||M).replace(/\/+$/,"")}async function A(t,o,l,s,f){try{const a=await fetch(`${o}/v1/rerank`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({model:t,query:l,documents:s.map(n=>n.text),top_n:s.length}),signal:AbortSignal.timeout(f)});if(!a.ok)return null;const r=(await a.json())?.results;if(!Array.isArray(r)||r.length===0)return null;const i=new Map;for(const n of r){if(typeof n.index!="number"||n.index<0||n.index>=s.length)continue;const e=typeof n.relevance_score=="number"?n.relevance_score:typeof n.score=="number"?n.score:null;e==null||!Number.isFinite(e)||i.set(s[n.index].id,e)}return i.size>0?i:null}catch{return null}}async function d(t,o,l={}){const s=process.env.WYRM_RERANK_MODEL?.trim();if(!s||!t||o.length===0)return null;const f=p(),a=l.timeoutMs??m(),R=Math.max(1,Math.min(5,l.batchSize??5)),r=new Map;for(let n=0;n<o.length;n+=R){const e=o.slice(n,n+R),c=await A(s,f,t,e,a);if(c)for(const[u,_]of c)r.set(u,_)}if(r.size===0)return null;const i=new Map(o.map((n,e)=>[n.id,e]));return[...o].sort((n,e)=>{const c=r.get(n.id),u=r.get(e.id);return c!=null&&u!=null?u-c:c!=null?-1:u!=null?1:(i.get(n.id)??0)-(i.get(e.id)??0)})}export{d as rerankCandidates,T as rerankConfigured};
+/**
+ * Cross-encoder rerank stage for hybrid recall — Ghost Protocol local
+ * multi-model ROUTER, subsystem wyrm-routing-rerank.
+ *
+ * The optional final leg of `recallHybrid`: FTS ⊕ vector fusion produces a
+ * top-K candidate set, this re-scores each candidate AGAINST the query with a
+ * true cross-encoder (query+document attend jointly, unlike the bi-encoder
+ * cosine the fusion uses), and the caller keeps the top-N. Cross-encoders are
+ * the strongest reranking signal in IR; the cost is a forward pass per
+ * candidate, which is why this is depth-bounded (top-K, not the whole corpus)
+ * and OFF by default.
+ *
+ * MODEL: bge-reranker-v2-m3 served by llama.cpp's OpenAI-style `/v1/rerank`
+ * endpoint (Jina/Cohere reranker wire shape:
+ *   POST { model, query, documents: string[], top_n } ->
+ *        { results: [{ index, relevance_score }, ...] }).
+ * Configured ENTIRELY by environment so Wyrm carries NO new dependency and the
+ * reranker is opt-in:
+ *   WYRM_RERANK_MODEL    — model id passed to /v1/rerank. UNSET ⇒ rerank is a
+ *                          no-op (the whole feature is gated on this).
+ *   WYRM_RERANK_URL      — base URL of the llama.cpp server
+ *                          (default http://localhost:8088).
+ *   WYRM_RERANK_TIMEOUT  — per-request timeout in ms (default 500).
+ *
+ * RESILIENCE CONTRACT (the recallHybrid `rerank:true` promise): this NEVER
+ * throws and NEVER hangs. On ANY error — model unset, endpoint down, timeout,
+ * malformed body, partial coverage — it returns null and the caller falls back
+ * to the fusion order. A reranker that is slow or absent must degrade recall to
+ * "exactly the fusion result", never to an error or a stall.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+/** Max documents sent in one /v1/rerank request (the task's batch<=5 cap). A
+ *  larger candidate set is split into sequential batches of this size. */
+const RERANK_BATCH = 5;
+/** Default per-request timeout (ms) when WYRM_RERANK_TIMEOUT is unset/invalid. */
+const DEFAULT_TIMEOUT_MS = 500;
+/** Default llama.cpp server base URL when WYRM_RERANK_URL is unset. */
+const DEFAULT_RERANK_URL = 'http://localhost:8088';
+/** True when a rerank model is configured (the feature is opt-in via env). */
+export function rerankConfigured() {
+    return !!(process.env.WYRM_RERANK_MODEL && process.env.WYRM_RERANK_MODEL.trim());
+}
+function rerankTimeoutMs() {
+    const raw = Number(process.env.WYRM_RERANK_TIMEOUT);
+    return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_TIMEOUT_MS;
+}
+function rerankBaseUrl() {
+    const raw = (process.env.WYRM_RERANK_URL || '').trim();
+    return (raw || DEFAULT_RERANK_URL).replace(/\/+$/, '');
+}
+/** One /v1/rerank call over a <=RERANK_BATCH slice. Returns an id→score map,
+ *  or null on any failure (timeout, non-200, malformed body). Never throws. */
+async function rerankBatch(model, baseUrl, query, batch, timeoutMs) {
+    try {
+        const res = await fetch(`${baseUrl}/v1/rerank`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model,
+                query,
+                documents: batch.map((c) => c.text),
+                top_n: batch.length,
+            }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        const results = data?.results;
+        if (!Array.isArray(results) || results.length === 0)
+            return null;
+        const out = new Map();
+        for (const r of results) {
+            // The reranker returns `index` into the documents array we sent; map it
+            // back to the candidate id. Tolerate `score` as an alias for some builds.
+            if (typeof r.index !== 'number' || r.index < 0 || r.index >= batch.length)
+                continue;
+            const score = typeof r.relevance_score === 'number' ? r.relevance_score
+                : typeof r.score === 'number' ? r.score : null;
+            if (score == null || !Number.isFinite(score))
+                continue;
+            out.set(batch[r.index].id, score);
+        }
+        return out.size > 0 ? out : null;
+    }
+    catch {
+        // timeout / connection refused / abort / JSON error — all degrade to null.
+        return null;
+    }
+}
+/**
+ * Rerank `candidates` against `query` with the configured cross-encoder and
+ * return them ordered best-first (highest relevance_score). Sends <=batchSize
+ * documents per /v1/rerank call (sequential batches). Returns null — the
+ * signal for "fall back to fusion order" — when:
+ *   - no model is configured (WYRM_RERANK_MODEL unset),
+ *   - there are no candidates,
+ *   - the endpoint is unreachable/slow/erroring for EVERY batch,
+ *   - or no candidate received a usable score.
+ * A PARTIAL success (some batches scored, some not) still returns an order:
+ * scored candidates rank by their cross-encoder score, unscored ones keep
+ * their original (fusion) order and trail the scored set — strictly no worse
+ * than the fusion order, and never a thrown error.
+ */
+export async function rerankCandidates(query, candidates, opts = {}) {
+    const model = process.env.WYRM_RERANK_MODEL?.trim();
+    if (!model)
+        return null; // feature gated on the model env
+    if (!query || candidates.length === 0)
+        return null;
+    const baseUrl = rerankBaseUrl();
+    const timeoutMs = opts.timeoutMs ?? rerankTimeoutMs();
+    const batchSize = Math.max(1, Math.min(RERANK_BATCH, opts.batchSize ?? RERANK_BATCH));
+    const scores = new Map();
+    for (let i = 0; i < candidates.length; i += batchSize) {
+        const batch = candidates.slice(i, i + batchSize);
+        const batchScores = await rerankBatch(model, baseUrl, query, batch, timeoutMs);
+        if (batchScores)
+            for (const [id, s] of batchScores)
+                scores.set(id, s);
+    }
+    if (scores.size === 0)
+        return null; // nothing scored → fusion order wins
+    // Scored candidates first (by cross-encoder score desc); any unscored ones
+    // (a failed batch) keep their original relative order and trail — so the
+    // result is never worse than the incoming fusion order.
+    const origIndex = new Map(candidates.map((c, i) => [c.id, i]));
+    return [...candidates].sort((a, b) => {
+        const sa = scores.get(a.id);
+        const sb = scores.get(b.id);
+        if (sa != null && sb != null)
+            return sb - sa;
+        if (sa != null)
+            return -1; // scored before unscored
+        if (sb != null)
+            return 1;
+        return (origIndex.get(a.id) ?? 0) - (origIndex.get(b.id) ?? 0); // stable
+    });
+}
+//# sourceMappingURL=rerank.js.map