@aiwayds/dsh-topics-memory 0.18.2 → 0.20.0

package/lib/jev/log.js

@@ -0,0 +1,121 @@
+/**
+ * decisions.jsonl — System One usage/optimization telemetry (design
+ * 2026-09-25 §6), always on while jevEnabled is on. Lives beside the ilog at
+ * `<bundle>/meta/decisions.jsonl` under the same discipline: 512KB
+ * auto-compaction keeping the most recent quarter, line JSON, and write
+ * failures swallowed silently — fail-open extends to the stats itself.
+ *
+ * REDACTION INVARIANT (§6.1): metadata and probabilities only — slug/pair
+ * hash/question type/score/latency/token count. NEVER the state text or
+ * conclusion bodies. Writers copy an explicit field whitelist, so extra
+ * fields on caller objects cannot leak into the file.
+ *
+ * @module jev/log
+ */
+import { appendFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { metaDir, resolveBundleRoot } from "../paths.js";
+const COMPACT_LIMIT = 512 * 1024; // ~512KB cap, same as the ilog sidecars
+export function decisionsFile(root) {
+    return join(metaDir(root), 'decisions.jsonl');
+}
+function liveFile() {
+    return decisionsFile(resolveBundleRoot());
+}
+/** digest(state, questionId, instructions): `h1:` + first 16 hex of
+ *  sha256(state + NUL + questionId + NUL + instructions) — the key the
+ *  repeat-decision-rate analysis joins on. */
+export function digestFor(state, questionId, instructions) {
+    const h = createHash('sha256');
+    h.update(state);
+    h.update('\u0000');
+    h.update(questionId);
+    h.update('\u0000');
+    h.update(instructions);
+    return `h1:${h.digest('hex').slice(0, 16)}`;
+}
+// Serialized like the store's write queue: single-record appends are
+// line-atomic anyway, but the compaction rewrite must not interleave with
+// an append.
+let queue = Promise.resolve();
+function enqueue(op) {
+    const run = queue.then(op, op);
+    queue = run.catch(() => undefined);
+    return run;
+}
+/** All write failures die HERE — never upstream. */
+async function appendJsonl(lines) {
+    await enqueue(async () => {
+        try {
+            const file = liveFile();
+            await mkdir(dirname(file), { recursive: true });
+            await appendFile(file, lines.map((l) => `${l}\n`).join(''), 'utf8');
+            await compactIfNeeded(file);
+        }
+        catch {
+            // fail-open: a broken stats sink must never break the feature (§6.1)
+        }
+    });
+}
+// store.ts compactInjectionsIfNeeded pattern: ~512KB cap; keep the most
+// recent quarter when exceeded (headroom for the next window).
+async function compactIfNeeded(file) {
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch {
+        return;
+    }
+    if (raw.length <= COMPACT_LIMIT)
+        return;
+    const lines = raw.split('\n').filter((l) => l.trim() !== '');
+    const keep = lines.slice(-Math.max(1, Math.floor(lines.length / 4)));
+    const tmp = `${file}.tmp-${randomUUID()}`;
+    try {
+        await writeFile(tmp, keep.map((l) => `${l}\n`).join(''), 'utf8');
+        await rename(tmp, file);
+    }
+    catch {
+        // swallow — the next append retries the compaction
+    }
+}
+/** Call-layer row. Field whitelist enforced here: anything extra on the
+ *  caller's object is dropped, so no state/conclusion text can sneak in. */
+export async function logCall(rec) {
+    await appendJsonl([
+        JSON.stringify({
+            at: rec.at,
+            lane: rec.lane,
+            backend: rec.backend,
+            model: rec.model,
+            questionCount: rec.questionCount,
+            stateChars: rec.stateChars,
+            latencyMs: rec.latencyMs,
+            usage: rec.usage === null
+                ? null
+                : { input_tokens: rec.usage.input_tokens, output_tokens: rec.usage.output_tokens },
+            outcome: rec.outcome,
+            fallback: rec.fallback,
+        }),
+    ]);
+}
+/** Verdict-layer rows (batch expanded by the caller). */
+export async function logVerdicts(recs) {
+    if (recs.length === 0)
+        return;
+    await appendJsonl(recs.map((rec) => JSON.stringify({
+        at: rec.at,
+        lane: rec.lane,
+        questionId: rec.questionId,
+        qtype: rec.qtype,
+        ref: rec.ref,
+        digest: rec.digest,
+        probability: rec.probability,
+        band: rec.band,
+        agree: rec.agree,
+        backend: rec.backend ?? 'primary',
+        degraded: rec.degraded === true,
+    })));
+}

package/lib/jev/thresholds.d.ts

@@ -0,0 +1,21 @@
+/**
+ * System One decision bands (design 2026-09-25 §5).
+ *
+ * The numbers are CALIBRATED — single-case A/B plus a 383-case threshold
+ * sweep (2026-09-25) — and bound to the batch wire protocol (protocol-drift
+ * evidence: the same case scores differently single vs batch). Changing the
+ * protocol requires a re-sweep; do not tune these in place.
+ *
+ * @module jev/thresholds
+ */
+/** Slow-lane rerank (候选问): adopt ≥ 0.60, strong-veto < 0.10. */
+export declare const RERANK_ADOPT = 0.6;
+export declare const RERANK_FALLBACK = 0.1;
+/** Consolidation prefilter (pair 问「同一问题吗」): adopt ≥ 0.50, veto < 0.15. */
+export declare const MERGE_PAIR_ADOPT = 0.5;
+export declare const MERGE_PAIR_FALLBACK = 0.15;
+export type JevBand = 'adopt' | 'record' | 'fallback';
+export type JevBandKind = 'rerank' | 'mergePair';
+/** Map a noul probability to its band: adopt → act on it, record → only log
+ *  it, fallback → hard veto back to the lexical/legacy behavior. */
+export declare function band(probability: number, kind: JevBandKind): JevBand;

package/lib/jev/thresholds.js

@@ -0,0 +1,27 @@
+/**
+ * System One decision bands (design 2026-09-25 §5).
+ *
+ * The numbers are CALIBRATED — single-case A/B plus a 383-case threshold
+ * sweep (2026-09-25) — and bound to the batch wire protocol (protocol-drift
+ * evidence: the same case scores differently single vs batch). Changing the
+ * protocol requires a re-sweep; do not tune these in place.
+ *
+ * @module jev/thresholds
+ */
+/** Slow-lane rerank (候选问): adopt ≥ 0.60, strong-veto < 0.10. */
+export const RERANK_ADOPT = 0.6;
+export const RERANK_FALLBACK = 0.1;
+/** Consolidation prefilter (pair 问「同一问题吗」): adopt ≥ 0.50, veto < 0.15. */
+export const MERGE_PAIR_ADOPT = 0.5;
+export const MERGE_PAIR_FALLBACK = 0.15;
+/** Map a noul probability to its band: adopt → act on it, record → only log
+ *  it, fallback → hard veto back to the lexical/legacy behavior. */
+export function band(probability, kind) {
+    const floor = kind === 'rerank' ? RERANK_FALLBACK : MERGE_PAIR_FALLBACK;
+    const adopt = kind === 'rerank' ? RERANK_ADOPT : MERGE_PAIR_ADOPT;
+    if (probability >= adopt)
+        return 'adopt';
+    if (probability >= floor)
+        return 'record';
+    return 'fallback';
+}

package/lib/quality.d.ts

@@ -5,8 +5,12 @@
  *   1. intent-query build over the observer's last-K ring buffer — kills
  *      verbatim priming at the root (the query is what the model needs, not
  *      what the user typed);
- *   2. lexical candidate band (hits + near-misses, recall-oriented) then an
- *      LLM rerank that releases 0-2 picks, each with a one-line why.
+ *   2. lexical candidate band (hits + near-misses, recall-oriented) then a
+ *      rerank that releases 0-2 picks, each with a one-line why. With
+ *      `jevEnabled` on (design 2026-09-25 §2) the rerank is a batched System
+ *      One noul request, probability-band gated; any failure fails open to the
+ *      legacy LLM rerank below. The same trigger also runs the fastgate
+ *      SHADOW (zero behavior, decisions.jsonl only).
  *
  * Picks rest in a per-session pending slot and inject at the NEXT spliced
  * (steer message), then the slot is gone (消费即清). Hard bounds: per-call
@@ -28,8 +32,32 @@ export declare const CALL_TIMEOUT_MS = 20000;
 export declare const PIPELINE_TIMEOUT_MS = 45000;
 /** qualityLane 'sampled' runs on every Nth turn (design default 1/3). */
 export declare const SAMPLED_EVERY = 3;
+/** Fastgate shadow cap (design §2 row 3): topK hits + near-misses, ≤8 questions. */
+export declare const FASTGATE_MAX_QUESTIONS = 8;
 export declare const QUERY_BUILD_PROMPT: string;
 export declare const RERANK_PROMPT: string;
+/**
+ * §6.2 state for one batch: the round's query plus the task frame. Shared by
+ * the rerank and the fastgate shadow so both seams speak ONE batch protocol —
+ * the calibrated bands are protocol-bound (design §5), a second state shape
+ * would need its own sweep.
+ */
+export declare function jevState(query: string): string;
+/** The lexical disposition the fast lane recorded for one candidate — the
+ *  agree-reconciliation key (§6.2; retrieval.ts hits/nearMisses split). */
+export type FastGateDisposition = 'hit' | 'nearFloor' | 'gate-blocked';
+export interface FastGateCandidate {
+    slug: string;
+    disposition: FastGateDisposition;
+}
+export interface FastGateShadowInput {
+    /** The fast-lane round's query (the claimed text), captured at spliced. */
+    query: string;
+    /** hits + near-misses of that round, with their lexical dispositions. */
+    candidates: readonly FastGateCandidate[];
+    /** Observer turn count at the trigger — the sampled-cadence clock. */
+    turnId: number;
+}
 export interface PendingInjection {
     items: {
         slug: string;
@@ -64,6 +92,8 @@ export declare function parseJsonObject(raw: string): Record<string, unknown>;
 export declare class SlowLane {
     private pending;
     private inFlight;
+    /** Same-session shadow serialization — a second trigger never overlaps. */
+    private shadowInFlight;
     private readonly service;
     private readonly caller;
     /**
@@ -81,6 +111,19 @@ export declare class SlowLane {
     hasInFlight(sessionId: string): boolean;
     /** Drop the pending slot (session teardown, restore boundary). */
     clear(sessionId: string): void;
+    /**
+     * Fastgate shadow (design §2 row 3): fire-and-forget on the SAME sampled
+     * turn-end trigger as the slow lane, zero behavior — verdicts land only in
+     * decisions.jsonl, reconciled against the lexical disposition. Needs no LLM
+     * caller, so it also runs on turns where the slow lane itself yields (distill
+     * in flight, no model configured). `dispatch()`'s own guards (lane mode,
+     * sampled cadence) are mirrored here so both seams share one cadence.
+     */
+    dispatchFastGateShadow(sessionId: string, input: FastGateShadowInput): void;
+    /** Shadow body: resolve candidate content from the roster, one batched noul
+     *  request, verdict rows only. A jevAsk failure leaves just its auto-written
+     *  call row — there is no legacy path to fall back to, and nothing to gate. */
+    private fastGateShadow;
     /**
      * Produce a pending slot for the session's next steer message. Fire-and-
      * forget; every guard failure is silent. Policy gates live here (config,
@@ -89,6 +132,21 @@ export declare class SlowLane {
      */
     dispatch(sessionId: string, input: DispatchInput): void;
     private produce;
+    /** One pending slot per settled pipeline (the 0-2 picks + lane metadata). */
+    private settlePending;
+    /**
+     * The jev rerank (design §2 row 1): one batched noul request over the whole
+     * candidate band; per-candidate verdict rows (agree: 'n/a' — no lexical
+     * disposition applies on this seam). Gate: adopt band (≥ 0.60) ranked by
+     * probability, top 2 (the 0-2 picks semantics); record band only logs;
+     * fallback band (< 0.10) is a hard veto.
+     *
+     * Returns undefined on ANY failure — jevAsk !ok (timeout / network / gate /
+     * bad shape) or an unparseable probability (坏答案) — so the caller fails
+     * open to the legacy LLM rerank (red line ②; the call-layer row already
+     * carries fallback=true via jevAsk's flag).
+     */
+    private jevRerank;
     /**
      * Consumption point (the next spliced). Returns the pending exactly once
      * (消费即清) or an expiry reason; `turnId` is the CURRENT observer turn

package/lib/quality.js

@@ -5,8 +5,12 @@
  *   1. intent-query build over the observer's last-K ring buffer — kills
  *      verbatim priming at the root (the query is what the model needs, not
  *      what the user typed);
- *   2. lexical candidate band (hits + near-misses, recall-oriented) then an
- *      LLM rerank that releases 0-2 picks, each with a one-line why.
+ *   2. lexical candidate band (hits + near-misses, recall-oriented) then a
+ *      rerank that releases 0-2 picks, each with a one-line why. With
+ *      `jevEnabled` on (design 2026-09-25 §2) the rerank is a batched System
+ *      One noul request, probability-band gated; any failure fails open to the
+ *      legacy LLM rerank below. The same trigger also runs the fastgate
+ *      SHADOW (zero behavior, decisions.jsonl only).
  *
  * Picks rest in a per-session pending slot and inject at the NEXT spliced
  * (steer message), then the slot is gone (消费即清). Hard bounds: per-call
@@ -18,6 +22,9 @@
  * @module quality
  */
 import { searchTopics } from "./retrieval.js";
+import { jevAskDual } from "./jev/dual.js";
+import { band as jevBand } from "./jev/thresholds.js";
+import { digestFor, logVerdicts } from "./jev/log.js";
 export const PENDING_TTL_MS = 10 * 60_000;
 /** Hard drift bound: a pending older than this many turn-ends expires. */
 export const TURN_LAG_LIMIT = 2;
@@ -31,6 +38,8 @@ const RING_CHARS = 6000;
 const CANDIDATE_LIMIT = 6;
 /** Over-fetch before the exclude filter, so excluded slugs don't thin the band. */
 const CANDIDATE_OVERFETCH = 6;
+/** Fastgate shadow cap (design §2 row 3): topK hits + near-misses, ≤8 questions. */
+export const FASTGATE_MAX_QUESTIONS = 8;
 export const QUERY_BUILD_PROMPT = [
     '你是检索查询构建器。输入是最近几轮对话。任务：判断「模型此刻需要什么背景知识」，输出一个用于关键词检索的 query。',
     '只输出一个 JSON 对象，不要任何其他文字：{"needs": true, "query": "3-8 个检索词加一句意图", "ignore": ["被你忽略的内容类型"]}',
@@ -47,6 +56,77 @@ export const RERANK_PROMPT = [
     '- why 面向模型自己读：说清这条记忆能帮上当前哪一步。',
     '- slug 必须逐字取自候选列表，禁止编造。',
 ].join('\n');
+/**
+ * §6.2 state for one batch: the round's query plus the task frame. Shared by
+ * the rerank and the fastgate shadow so both seams speak ONE batch protocol —
+ * the calibrated bands are protocol-bound (design §5), a second state shape
+ * would need its own sweep.
+ */
+export function jevState(query) {
+    return `检索 query：${query}\n任务背景：模型正在推进当前会话的工作，需要判断哪些长期记忆 topic 值得注入上下文作参考。`;
+}
+/** Per-candidate question: full candidate inline (title/tags/conclusion
+ *  excerpt), RERANK_PROMPT's rendering style but compact. */
+function candidateInstructions(c) {
+    const tags = c.tags !== undefined && c.tags.length > 0 ? `，标签: ${c.tags.join('/')}` : '';
+    const desc = c.description !== undefined && c.description.trim() !== '' ? ` ${c.description.trim().slice(0, 80)}` : '';
+    return `候选 topic「${c.title}」（slug: ${c.slug}，状态: ${c.status}${tags}）。${desc}结论摘录：${c.conclusion.slice(0, 160)}。该候选与当前 query 对应的工作真的相关、值得注入模型上下文吗？`;
+}
+/** Two-sided criteria built from the candidate content (calibration protocol:
+ *  single-sided instructions measurably degrade). */
+function candidateCriteria(c) {
+    return {
+        true: `相关——「${c.title}」的记忆对当前工作有实质帮助，应该注入作参考`,
+        false: `无关——「${c.title}」与当前工作没有实质交集，注入只是噪音，不应该注入`,
+    };
+}
+/** The noul probability of one answer; undefined when the answer is not a
+ *  usable number in [0,1] (a 坏答案 — fail-open for the caller). */
+function noulProbability(answer) {
+    if (answer === null || typeof answer !== 'object')
+        return undefined;
+    const p = answer.noul;
+    return typeof p === 'number' && Number.isFinite(p) && p >= 0 && p <= 1 ? p : undefined;
+}
+/** Pace-maker comparison rows for the slow rerank (design §3.4, REVISED
+ *  09-27): laya is TELEMETRY ONLY, so its rows are recorded band='record'
+ *  (its absolute scores never claim adopt) and degraded=false whether or not
+ *  the primary answered — landing them costs no behavior. An unparseable
+ *  answer gets no fabricated row. */
+function layaRerankRows(at, state, metas, answers) {
+    const recs = [];
+    for (const m of metas) {
+        const probability = noulProbability(answers?.[m.qid]);
+        if (probability === undefined)
+            continue;
+        recs.push({
+            at,
+            lane: 'slowlane-rerank',
+            questionId: m.qid,
+            qtype: 'noul',
+            ref: `slug:${m.slug}`,
+            digest: digestFor(state, m.qid, m.instructions),
+            probability,
+            band: 'record',
+            agree: 'n/a',
+            backend: 'laya',
+            degraded: false,
+        });
+    }
+    return recs;
+}
+/** The config slice jevAsk needs, tolerating bare harnesses (§4: consumers
+ *  treat undefined as the documented default). */
+function jevConfigOf(cfg) {
+    return {
+        jevBackend: cfg.jevBackend ?? 'zen',
+        jevModel: cfg.jevModel ?? '',
+        jevTimeoutMs: typeof cfg.jevTimeoutMs === 'number' && cfg.jevTimeoutMs > 0 ? cfg.jevTimeoutMs : 3000,
+        jevSecretFile: cfg.jevSecretFile ?? '',
+        jevLayaFallback: cfg.jevLayaFallback === true,
+        jevLayaUrl: cfg.jevLayaUrl ?? 'http://127.0.0.1:8000/v1/systemone',
+    };
+}
 /** Race `p` against a timeout; `onTimeout` fires so callers can abort upstream work. */
 function withTimeout(p, ms, onTimeout) {
     return new Promise((resolve, reject) => {
@@ -107,6 +187,8 @@ export function parseJsonObject(raw) {
 export class SlowLane {
     pending = new Map();
     inFlight = new Map();
+    /** Same-session shadow serialization — a second trigger never overlaps. */
+    shadowInFlight = new Map();
     service;
     caller;
     /**
@@ -133,6 +215,106 @@ export class SlowLane {
     /** Drop the pending slot (session teardown, restore boundary). */
     clear(sessionId) {
         this.pending.delete(sessionId);
+        this.shadowInFlight.delete(sessionId);
+    }
+    /**
+     * Fastgate shadow (design §2 row 3): fire-and-forget on the SAME sampled
+     * turn-end trigger as the slow lane, zero behavior — verdicts land only in
+     * decisions.jsonl, reconciled against the lexical disposition. Needs no LLM
+     * caller, so it also runs on turns where the slow lane itself yields (distill
+     * in flight, no model configured). `dispatch()`'s own guards (lane mode,
+     * sampled cadence) are mirrored here so both seams share one cadence.
+     */
+    dispatchFastGateShadow(sessionId, input) {
+        try {
+            const cfg = this.service.cfg;
+            if (cfg.jevEnabled !== true)
+                return;
+            if (cfg.qualityLane !== 'sampled' && cfg.qualityLane !== 'always')
+                return;
+            if (cfg.qualityLane === 'sampled' && input.turnId % SAMPLED_EVERY !== 0)
+                return;
+            if (input.query.trim() === '' || input.candidates.length === 0)
+                return;
+            if (this.shadowInFlight.has(sessionId))
+                return; // never overlap shadows
+            // Serialize behind a same-session produce pipeline (rerank 完成后);
+            // standalone when no pipeline is running (无慢道任务时独立跑).
+            const prior = this.inFlight.get(sessionId) ?? Promise.resolve();
+            const run = prior.then(() => this.fastGateShadow(input)).finally(() => {
+                this.shadowInFlight.delete(sessionId);
+            });
+            this.shadowInFlight.set(sessionId, run);
+            void run.catch(() => undefined);
+        }
+        catch {
+            // contained — the shadow must never break the event handler
+        }
+    }
+    /** Shadow body: resolve candidate content from the roster, one batched noul
+     *  request, verdict rows only. A jevAsk failure leaves just its auto-written
+     *  call row — there is no legacy path to fall back to, and nothing to gate. */
+    async fastGateShadow(input) {
+        const roster = await this.service.roster().catch(() => []);
+        const bySlug = new Map(roster.map((r) => [r.slug, r]));
+        const state = jevState(input.query);
+        const questions = {};
+        const metas = [];
+        for (const cand of input.candidates.slice(0, FASTGATE_MAX_QUESTIONS)) {
+            const meta = bySlug.get(cand.slug);
+            if (meta === undefined)
+                continue; // vanished between retrieval and the shadow
+            const qid = `c${metas.length + 1}`;
+            const instructions = candidateInstructions(meta);
+            questions[qid] = { type: 'noul', instructions, criteria: candidateCriteria(meta) };
+            metas.push({ qid, slug: cand.slug, instructions, disposition: cand.disposition });
+        }
+        if (metas.length === 0)
+            return;
+        const dual = await jevAskDual({
+            state,
+            questions,
+            config: jevConfigOf(this.service.cfg),
+            lane: 'fastgate-shadow',
+            fallback: false, // pure shadow — no behavior to fall back
+        });
+        const at = new Date().toISOString();
+        // Verdict rows for BOTH sources when they answered: the primary row set
+        // and the laya pace-maker comparison set (backend='laya', excluded from
+        // ECE, §6.2). Pure shadow — nothing gates here, so the laya rows land
+        // whenever laya answered, primary success or not.
+        const sources = [];
+        if (dual.ok)
+            sources.push({ answers: dual.answers, backend: 'primary', degraded: false });
+        if (dual.layaResult?.ok)
+            sources.push({ answers: dual.layaResult.answers, backend: 'laya', degraded: false });
+        const recs = [];
+        for (const src of sources) {
+            for (const m of metas) {
+                const probability = noulProbability(src.answers?.[m.qid]);
+                if (probability === undefined)
+                    continue; // unparseable answer: no fabricated row
+                const b = jevBand(probability, 'rerank');
+                // agree reconciliation (§6.2): the ilog disposition, with wouldBlock for
+                // the reverse disagreement (lexical let it through, jev lands in the veto
+                // band — the other half of the calibration goldmine).
+                const agree = m.disposition === 'hit' && b === 'fallback' ? 'wouldBlock' : m.disposition;
+                recs.push({
+                    at,
+                    lane: 'fastgate-shadow',
+                    questionId: m.qid,
+                    qtype: 'noul',
+                    ref: `slug:${m.slug}`,
+                    digest: digestFor(state, m.qid, m.instructions),
+                    probability,
+                    band: b,
+                    agree,
+                    backend: src.backend,
+                    degraded: src.degraded,
+                });
+            }
+        }
+        await logVerdicts(recs);
     }
     /**
      * Produce a pending slot for the session's next steer message. Fire-and-
@@ -237,6 +419,19 @@ export class SlowLane {
             });
             if (payload.length === 0)
                 return;
+            // ---- jev batch rerank (design §2 row 1) — replaces the LLM rerank ----
+            // One batched noul request over the whole band; the calibrated bands
+            // decide the picks. A settled jev round is FINAL here (picks or none) —
+            // only a jev FAILURE (jevRerank → undefined) falls open to the legacy
+            // LLM rerank below (§3.2: 本轮回退旧 LLM rerank, picks 照常产出).
+            if (this.service.cfg.jevEnabled === true) {
+                const jevItems = await this.jevRerank(query, payload);
+                if (jevItems !== undefined) {
+                    if (jevItems.length > 0)
+                        this.settlePending(sessionId, input, jevItems, queryBuild, started);
+                    return;
+                }
+            }
             const rerankRaw = await withTimeout(caller({
                 system: RERANK_PROMPT,
                 user: [
@@ -279,15 +474,7 @@ export class SlowLane {
             }
             if (items.length === 0)
                 return;
-            const route = this.service.cfg;
-            this.pending.set(sessionId, {
-                items,
-                computedAt: new Date().toISOString(),
-                turnId: input.turnId,
-                queryBuild,
-                model: `${route.distillProvider}/${route.distillModel}`,
-                ms: Date.now() - started,
-            });
+            this.settlePending(sessionId, input, items, queryBuild, started);
         }
         catch {
             // timeouts, aborts, model errors — I3: the async product is simply absent
@@ -296,6 +483,98 @@ export class SlowLane {
             clearTimeout(deadline);
         }
     }
+    /** One pending slot per settled pipeline (the 0-2 picks + lane metadata). */
+    settlePending(sessionId, input, items, queryBuild, started) {
+        const route = this.service.cfg;
+        this.pending.set(sessionId, {
+            items,
+            computedAt: new Date().toISOString(),
+            turnId: input.turnId,
+            queryBuild,
+            model: `${route.distillProvider}/${route.distillModel}`,
+            ms: Date.now() - started,
+        });
+    }
+    /**
+     * The jev rerank (design §2 row 1): one batched noul request over the whole
+     * candidate band; per-candidate verdict rows (agree: 'n/a' — no lexical
+     * disposition applies on this seam). Gate: adopt band (≥ 0.60) ranked by
+     * probability, top 2 (the 0-2 picks semantics); record band only logs;
+     * fallback band (< 0.10) is a hard veto.
+     *
+     * Returns undefined on ANY failure — jevAsk !ok (timeout / network / gate /
+     * bad shape) or an unparseable probability (坏答案) — so the caller fails
+     * open to the legacy LLM rerank (red line ②; the call-layer row already
+     * carries fallback=true via jevAsk's flag).
+     */
+    async jevRerank(query, payload) {
+        const state = jevState(query);
+        const questions = {};
+        const metas = [];
+        for (const [i, c] of payload.entries()) {
+            const qid = `c${i + 1}`;
+            const instructions = candidateInstructions(c);
+            questions[qid] = { type: 'noul', instructions, criteria: candidateCriteria(c) };
+            metas.push({ qid, slug: c.slug, instructions });
+        }
+        const dual = await jevAskDual({
+            state,
+            questions,
+            config: jevConfigOf(this.service.cfg),
+            lane: 'slowlane-rerank',
+            fallback: false,
+            // fallback stays FALSE here: jevAsk writes the row before the caller
+            // knows the outcome, so a constant true would poison the rollback-rate
+            // stat. Fail-open occurrence = outcome !== 'ok' (this lane's fallback
+            // to the legacy LLM rerank is deterministic per ADR 0018).
+        });
+        // REVISED 09-27 (real-data evidence): the laya pace-maker is TELEMETRY
+        // ONLY. Its within-batch top-1 agreed with the primary 0/14 on real
+        // queries (and its negatives sit at 0.63-0.76 — absolute scores unusable),
+        // so the earlier degraded-ranking takeover is REVERTED: on primary
+        // failure the lane falls open to the legacy LLM rerank exactly as
+        // ADR 0018 says. The pace-maker still answers, so its comparison rows
+        // land FIRST here (pure telemetry), then the legacy rerank takes over.
+        if (!dual.ok) {
+            if (dual.layaResult?.ok) {
+                await logVerdicts(layaRerankRows(new Date().toISOString(), state, metas, dual.layaResult.answers));
+            }
+            return undefined;
+        }
+        const scored = [];
+        for (const m of metas) {
+            const probability = noulProbability(dual.answers[m.qid]);
+            if (probability === undefined)
+                return undefined; // 坏答案 → fail-open (§1)
+            scored.push({ ...m, probability, band: jevBand(probability, 'rerank') });
+        }
+        const at = new Date().toISOString();
+        const recs = scored.map((m) => ({
+            at,
+            lane: 'slowlane-rerank',
+            questionId: m.qid,
+            qtype: 'noul',
+            ref: `slug:${m.slug}`,
+            digest: digestFor(state, m.qid, m.instructions),
+            probability: m.probability,
+            band: m.band,
+            agree: 'n/a',
+            backend: dual.source,
+            degraded: false,
+        }));
+        // Pace-maker comparison rows (design §3.4): when the primary drove and
+        // laya also answered, log laya's verdicts alongside — the permanently
+        // running laya-vs-jev comparison. band='record': laya's absolute scores
+        // never claim adopt.
+        if (dual.layaResult?.ok)
+            recs.push(...layaRerankRows(at, state, metas, dual.layaResult.answers));
+        await logVerdicts(recs);
+        return scored
+            .filter((m) => m.band === 'adopt')
+            .sort((a, b) => b.probability - a.probability)
+            .slice(0, 2)
+            .map((m) => ({ slug: m.slug, why: `jev 判定相关（p=${m.probability.toFixed(2)}）` }));
+    }
     /**
      * Consumption point (the next spliced). Returns the pending exactly once
      * (消费即清) or an expiry reason; `turnId` is the CURRENT observer turn

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-topics-memory",
-  "version": "0.18.2",
+  "version": "0.20.0",
   "description": "dsh-plugin: quality-first topic memory for dsh — a topic keeps the starting question, conclusion, impact and dependencies, not the process; local-first git-traced OKF bundle, budgeted LLM-free injection",
   "type": "module",
   "main": "lib/index.js",
@@ -42,7 +42,7 @@
     "build": "tsc -p tsconfig.json",
     "check": "tsc --noEmit -p tsconfig.json",
     "pretest": "tsc -p tsconfig.json",
-    "test": "node --test test/yaml.test.mjs test/okf.test.mjs test/retrieval.test.mjs test/digest.test.mjs test/ilog.test.mjs test/store.test.mjs test/paths.test.mjs test/git.test.mjs test/sync.test.mjs test/tools.test.mjs test/dedup.test.mjs test/commands.test.mjs test/onboard.test.mjs test/delegation.test.mjs test/observer.test.mjs test/distill.test.mjs test/consolidate.test.mjs test/viz.test.mjs test/corpus.test.mjs test/llm-scope.test.mjs test/quality.test.mjs test/replay-gate.test.mjs test/depends-repair.test.mjs test/skill.test.mjs test/fast-lane.test.mjs test/legacy-import.test.mjs",
+    "test": "node --test test/yaml.test.mjs test/okf.test.mjs test/retrieval.test.mjs test/digest.test.mjs test/ilog.test.mjs test/store.test.mjs test/paths.test.mjs test/git.test.mjs test/sync.test.mjs test/tools.test.mjs test/dedup.test.mjs test/commands.test.mjs test/onboard.test.mjs test/delegation.test.mjs test/observer.test.mjs test/distill.test.mjs test/consolidate.test.mjs test/viz.test.mjs test/corpus.test.mjs test/llm-scope.test.mjs test/quality.test.mjs test/replay-gate.test.mjs test/depends-repair.test.mjs test/skill.test.mjs test/fast-lane.test.mjs test/legacy-import.test.mjs test/jev-config.test.mjs test/jev-gate.test.mjs test/jev-client.test.mjs test/jev-log.test.mjs test/jev-dual.test.mjs test/jev-fastgate.test.mjs",
     "smoke": "node scripts/smoke-boot.mjs"
   },
   "dependencies": {},