@aiwayds/dsh-topics-memory 0.18.2 → 0.20.0

package/skills/dsh-topics-memory-laya/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: dsh-topics-memory-laya
+description: "为 dsh-topics-memory 的 jev 决策层安装并配置本地 laya 陪跑（laya-serve）。当用户要开启 jevLayaFallback、安装 laya、启动 laya-serve、配置 laya 端点、排查 laya 连接失败/陪跑不生效/decisions.jsonl 没有 laya 行时读本指南。覆盖：venv 创建、国内三镜像加速（清华 PyPI / hf-mirror / 禁 Xet）、checkpoint 下载、laya-serve 启动与自启、jevLayaFallback/jevLayaUrl 两键配置、真机验证（decisions.jsonl 出现 backend=laya 行）。触发词：laya、laya-serve、陪跑、本地决策、jevLaya、离线、8000 端口。"
+---
+
+# laya 本地陪跑安装与配置
+
+> laya 是开源的 System One 决策引擎（本地推理，jev 的同范式替身）。topics-memory 的
+> `jevLayaFallback: true` 会把每次 jev 调用并发一路本地 laya 请求作对照遥测。本指南把
+> 安装配置一次讲完；全程不涉及付费 API。
+
+## 前置检查（先判断要不要装）
+
+1. `curl -s --max-time 3 -o /dev/null -w "%{http_code}" -X POST http://127.0.0.1:8000/v1/systemone -H "content-type: application/json" -d '{"state":"w","questions":{"q":{"type":"noul","instructions":"w","criteria":{"true":"t","false":"f"}}}}'`
+   返回 200 = laya-serve 已在跑，**跳到「插件配置」**；连接拒绝 = 继续安装。
+2. `python3 --version` 需要 ≥ 3.10（3.13 以下优先，太新的版本 torch 轮子可能缺）。
+3. 磁盘 ≥ 5GB（torch + 两个 checkpoint）。
+
+## 安装（国内网络三件套必带，否则要么 100KB/s 要么挂死）
+
+```bash
+mkdir -p ~/laya-tryout && cd ~/laya-tryout
+uv venv --python 3.12 .venv            # 没有 uv: brew install uv；或 python3 -m venv .venv
+uv pip install --python .venv/bin/python \
+  --index-url https://pypi.tuna.tsinghua.edu.cn/simple "laya[serve]" hf_transfer
+```
+
+下载 checkpoint（两个共 ~1.5GB）——三个环境变量一个都不能少：
+
+```bash
+export HF_ENDPOINT=https://hf-mirror.com    # HF 直连国内常 <50KB/s
+export HF_HUB_DISABLE_XET=1                 # 新版 huggingface_hub 默认 Xet 协议，镜像不支持，会 0 字节挂死
+export HF_HUB_ENABLE_HF_TRANSFER=1          # 并行分块，断流自动续传
+.venv/bin/python -c "
+from laya import Router
+r = Router()
+r.preload(['english', 'multilingual'])
+print('checkpoints ok')
+"
+```
+
+## 启动 laya-serve
+
+```bash
+LAYA_PRELOAD=1 LAYA_MODELS=english,multilingual ~/laya-tryout/.venv/bin/laya-serve
+# binds 0.0.0.0:8000；进程前台跑，挂 nohup/tmux/launchd 由用户自选
+```
+
+- `LAYA_MODELS` 不设会尝试预载第三个 checkpoint（typed-decisions，再 +1.7GB）——陪跑用不到，别下。
+- 自启（macOS launchd）可选：写 `~/Library/LaunchAgents/com.laya.serve.plist` 指向上面命令；不开自启就要接受「重启后陪跑静默失效」（无 laya = 毫秒级连接拒绝，无害但没对照数据）。
+
+## 插件配置（在 profile patch 的 `dsh-topics-memory` 条目）
+
+```yaml
+config:
+  jevEnabled: true          # 决策层总开关（本身默认关）
+  jevLayaFallback: true     # laya 陪跑开关
+  # jevLayaUrl 默认就是 http://127.0.0.1:8000/v1/systemone，不改端口不用写
+```
+
+前置：`jevEnabled: true` 且已按主配置指南配好 jev 后端 key（zen 免费档默认；key 走 patch `env:` 块或 `JEV_KEYCHAIN`——dsh 会清洗 ambient KEY 变量）。
+
+## 验证（三步）
+
+1. `curl -s -X POST http://127.0.0.1:8000/v1/systemone -H "content-type: application/json" -d '{"state":"w","model":"laya-rl-agent","questions":{"q":{"type":"noul","instructions":"w","criteria":{"true":"t","false":"f"}}}}' | jq .answers` — 返回 noul 概率即 laya 侧通。
+2. 跑一轮真实会话（任意问题），然后：
+   `jq -r 'select(.backend=="laya") | [.ref,.probability] | @tsv' ~/.dsh/topics/meta/decisions.jsonl | head` — 出现 `backend:"laya"` 的判定行 = 陪跑生效。
+3. `~/.dsh/topics/meta/decisions.jsonl` 里同一 `digest` 应有成对的 primary/laya 行——这就是永久运行的 laya-vs-jev 对照数据。
+
+## 语义边界（必须向用户讲清）
+
+- laya 是**纯遥测对照，不参与决策**：真实负载实测其批内排序与 jev 一致率 0/14、负例分 0.63-0.76（绝对分不可用），主路失败照旧回退旧路径。
+- 判定质量上 zen/typesafe 的 jev 系远胜 laya；laya 的价值是免费对照数据流 + 离线可用。
+- laya 换语言（中→英）首次调用会触发 checkpoint 重载（数百 ms），陪跑场景无感。
+
+## 常见坑速查
+
+| 症状 | 原因 | 解法 |
+|---|---|---|
+| 下载 0 字节挂死 | Xet 协议 + 镜像不兼容 | `HF_HUB_DISABLE_XET=1` |
+| checkpoint 下载 <100KB/s | HF 直连 | `HF_ENDPOINT=https://hf-mirror.com` |
+| `z.string().volatile is not a function` 类插件报错 | （与 laya 无关）dsh 版本漂移 | 钉 0.1.7-rc 线，勿裸解析 |
+| decisions.jsonl 无 backend=laya 行 | laya-serve 没起 / jevLayaFallback 没开 / jevEnabled 没开 | 按「验证」步骤逐层查 |
+| 首次调用慢（秒级） | checkpoint 冷加载 | 预热一发即稳态（32-300ms） |

package/src/commands.ts

@@ -16,6 +16,7 @@ import type { ConsolidateResult } from './consolidate.ts'
 import { serializeTopicDoc, slugify, firstParagraph } from './okf.ts'
 import { buildGraph, renderGraphHtml } from './viz.ts'
 import { CONFIG_KEYS, displayKey, type ConfigKey, type TopicsConfigValue, parseConfigValue } from './config.ts'
+import { reloadSecrets } from './jev/gate.ts'
 import { aggregateStats } from './ilog.ts'
 import {
   askDistillSingle,
@@ -630,5 +631,6 @@ async function doSet(
   if (typeof parsed === 'object' && parsed !== null && 'error' in parsed) return fail(parsed.error)
   await mutate([{ op: 'set', path: [key], value: parsed }])
   if (key === 'repo' || key === 'autoInject') service.invalidate()
+  if (key === 'jevSecretFile') reloadSecrets(String(parsed)) // hot-swapped list: force re-read
   return ok(`✅ topics.${displayKey(key)} = ${String(parsed)}`)
 }

package/src/config.ts

@@ -74,6 +74,31 @@ export const TopicsConfig = z.object({
   usageBoost: z.number().default(0.15).volatile(),
   /** Debounced push delay in GitHub mode. */
   pushDebounceSeconds: z.number().default(45).volatile(),
+  /** System One decision-model integration (design 2026-09-25), default-off
+   *  master switch: false means zero behavior change anywhere (the fast lane
+   *  never calls out regardless — hard guard); the usage stats stop with it. */
+  jevEnabled: z.boolean().default(false).volatile(),
+  /** Decision backend: zen (free, opencode.ai) | native (typesafe
+   *  first-party) | openrouter (decisions protocol). */
+  jevBackend: z.string().default('zen').volatile(),
+  /** Pinned model id; '' = resolve the backend default at call time
+   *  (distillProvider sentinel pattern): jev-1.13-free / jev-1.13.0 /
+   *  typesafe/jev-1.13 — an upgrade is a deliberate act. */
+  jevModel: z.string().default('').volatile(),
+  /** Single-request timeout in ms; one AbortSignal, NO retry (the calling
+   *  lane's next cadence is the natural retry, fail-open hard-coded). */
+  jevTimeoutMs: z.number().default(3000).volatile(),
+  /** External secret list for the outbound secret gate (JEV_SECRET_FILE
+   *  semantics, design §3.3); swapping the path hot reloads the list. */
+  jevSecretFile: z.string().default('').volatile(),
+  /** Local laya pace-maker (design §3.4, 09-27): fire a parallel laya call on
+   *  every jev request; its verdict is logged for comparison and takes over
+   *  ONLY when the primary backend fails (degraded). Default off — zero
+   *  behavior change, and laya-serve not running costs a refused connection. */
+  jevLayaFallback: z.boolean().default(false).volatile(),
+  /** laya-serve systemone endpoint for the pace-maker (default: the local
+   *  laya-serve bind from the laya repo's serve mode). */
+  jevLayaUrl: z.string().default('http://127.0.0.1:8000/v1/systemone').volatile(),
 })
 
 export type TopicsConfigValue = {
@@ -103,6 +128,17 @@ export type TopicsConfigValue = {
   deprecatedTtlDays: number
   usageBoost: number
   pushDebounceSeconds: number
+  /** System One integration keys (design 2026-09-25 §4). Optional in this TS
+   *  view only: index.ts's bare-harness DEFAULTS literal predates them and
+   *  schemastery applies the runtime defaults on real hosts — consumers must
+   *  treat undefined as the documented default. */
+  jevEnabled?: boolean
+  jevBackend?: 'zen' | 'native' | 'openrouter'
+  jevModel?: string
+  jevTimeoutMs?: number
+  jevSecretFile?: string
+  jevLayaFallback?: boolean
+  jevLayaUrl?: string
 }
 
 export const CONFIG_KEYS = [
@@ -132,6 +168,13 @@ export const CONFIG_KEYS = [
   'deprecatedTtlDays',
   'usageBoost',
   'pushDebounceSeconds',
+  'jevEnabled',
+  'jevBackend',
+  'jevModel',
+  'jevTimeoutMs',
+  'jevSecretFile',
+  'jevLayaFallback',
+  'jevLayaUrl',
 ] as const
 
 export type ConfigKey = (typeof CONFIG_KEYS)[number]
@@ -155,11 +198,16 @@ export function parseConfigValue(key: ConfigKey, raw: string): boolean | number
     case 'suppressEcho':
     case 'autoObserve':
     case 'distillOnSessionEnd':
-    case 'includeSubagents': {
+    case 'includeSubagents':
+    case 'jevEnabled': {
       if (raw === 'on' || raw === 'true') return true
       if (raw === 'off' || raw === 'false') return false
       return { error: `${key} 取值 on|off` }
     }
+    case 'jevBackend': {
+      if (raw === 'zen' || raw === 'native' || raw === 'openrouter') return raw
+      return { error: 'jev-backend 取值 zen|native|openrouter' }
+    }
     case 'topK':
     case 'perTopicBudget':
     case 'totalBudget':
@@ -170,7 +218,8 @@ export function parseConfigValue(key: ConfigKey, raw: string): boolean | number
     case 'distillBatchSize':
     case 'distillMaxModelCalls':
     case 'deprecatedTtlDays':
-    case 'pushDebounceSeconds': {
+    case 'pushDebounceSeconds':
+    case 'jevTimeoutMs': {
       const n = Number(raw)
       if (!Number.isFinite(n) || n < 0 || !Number.isInteger(n)) return { error: `${key} 需要非负整数` }
       return n
@@ -196,6 +245,14 @@ export function parseConfigValue(key: ConfigKey, raw: string): boolean | number
     }
     case 'distillProvider':
     case 'distillModel':
+    case 'jevModel':
+    case 'jevSecretFile':
+    case 'jevLayaUrl':
       return raw
+    case 'jevLayaFallback': {
+      if (raw === 'on' || raw === 'true') return true
+      if (raw === 'off' || raw === 'false') return false
+      return { error: 'jev-laya-fallback 取值 on|off' }
+    }
   }
 }

package/src/consolidate.ts

@@ -23,13 +23,25 @@
  *  - the cadence stamp (meta/consolidate-state.json) advances only when the
  *    model actually evaluated at least one cluster — a run that died on the
  *    first call leaves the stamp alone, and the next session start retries.
+ *  - jev prefilter (design 2026-09-25 §2, default-off): with jevEnabled the
+ *    cluster first answers to ONE cheap System One batch (≤6 questions: the
+ *    top-5 similar pairs each ask 「同一问题吗」, plus a record-only
+ *    cluster-level 「值得动吗」). Only when ≥1 pair reaches the adopt band
+ *    (≥0.50) does the cluster go to the LLM — an all-non-adopt cluster skips
+ *    the model call entirely. Any jev failure fails open to today's behavior;
+ *    the merge conclusion generation itself stays LLM.
  *
  * @module consolidate
  */
 
 import * as okf from './okf.ts'
+import type { TopicsConfigValue } from './config.ts'
 import type { TopicsService } from './service.ts'
 import { parseOps, type ModelCaller } from './distill.ts'
+import { jevAsk, type JevAskConfig, type JevQuestion } from './jev/client.ts'
+import { band, type JevBand } from './jev/thresholds.ts'
+import { digestFor, logVerdicts } from './jev/log.ts'
+import type { JevVerdictRecord } from './jev/log.ts'
 
 /** Below this pairwise Jaccard two topics never share a cluster. */
 const CLUSTER_THRESHOLD = 0.3
@@ -42,6 +54,12 @@ const MAX_OPS_PER_RUN = 12
 /** Conclusion chars fed per topic in a cluster payload. */
 const CONCLUSION_SNIPPET_CHARS = 600
 const CONSOLIDATE_MAX_TOKENS = 2500
+/**
+ * Pair questions per cluster batch (design §2: k≤5, so with the record-only
+ * cluster-level question a batch stays ≤6 问/簇 — the measured cheap end of
+ * the batch protocol).
+ */
+const PREFILTER_TOP_PAIRS = 5
 
 export interface ConsolidateOp {
   op: 'merge' | 'promote' | 'deprecate' | 'refresh'
@@ -134,10 +152,22 @@ export interface ClusterEntry {
   conclusion: string
 }
 
+/** One similar pair inside a cluster — the jev prefilter's question units. */
+export interface ClusterPair {
+  /** Indices into the cluster's `entries`. */
+  i: number
+  j: number
+  /** Pairwise Jaccard from clustering — REUSED for the prefilter's pair
+   *  selection (top-k at ask time), never recomputed. */
+  similarity: number
+}
+
 export interface TopicCluster {
   entries: ClusterEntry[]
   /** Peak pairwise similarity inside the cluster — runs process peaks first. */
   similarity: number
+  /** Similar pairs (edges ≥ threshold) inside the cluster, best first. */
+  pairs: ClusterPair[]
 }
 
 /**
@@ -199,15 +229,101 @@ export function clusterTopics(
         .sort((a, b) => (degree.get(b) ?? 0) - (degree.get(a) ?? 0))
         .slice(0, MAX_CLUSTER_SIZE)
     }
+    // Reuse the clustering edges for the prefilter's pair list: positions map
+    // into the (possibly capped) kept order, best similarity first. Edges
+    // lost to the cap — or transitively-clustered pairs below threshold — are
+    // not pair candidates; a capped cluster with no inner edge left simply
+    // has no pairs (the prefilter then behaves as today).
+    const position = new Map<number, number>()
+    kept.forEach((original, pos) => position.set(original, pos))
+    const pairs: ClusterPair[] = []
+    for (const [key, s] of scores) {
+      const i = Math.floor(key / entries.length)
+      const j = key % entries.length
+      const pi = position.get(i)
+      const pj = position.get(j)
+      if (pi === undefined || pj === undefined) continue
+      pairs.push({ i: pi, j: pj, similarity: s })
+    }
+    pairs.sort((a, b) => b.similarity - a.similarity)
     clusters.push({
       entries: kept.map((i) => entries[i] as ClusterEntry),
       similarity: peak,
+      pairs,
     })
   }
   clusters.sort((a, b) => b.similarity - a.similarity)
   return clusters
 }
 
+// --- Jev prefilter protocol (design 2026-09-25 §2, sweep-aligned) ------------
+
+// The merge-pair thresholds (band(..., 'mergePair')) are BOUND to the t4
+// threshold-sweep batch protocol: shared state, two-sided criteria, two
+// 600-char side excerpts per question. Absolute scores are protocol-sensitive
+// (t4 §4: the same case scored 0.15 / 0.60 / 0.71 across protocols), so the
+// texts below are copied VERBATIM from
+// .wayfinder/research/t4-labeling-kit/threshold-sweep.mjs (MRG_STATE /
+// MRG_CRITERIA / mrgInstructions) — changing any of them requires a re-sweep
+// of the lines, do not tune in place.
+const PREFILTER_STATE = [
+  '背景：你在为一个个人记忆库做簇内 merge 校准。整理（consolidate）时会把讲同一问题的多个 topic 合并成一份；误并会造成信息丢失，漏并会造成库内冗余与后续漂移。',
+  '判定标准：同一问题指两条记录的是同一件事——同一 bug/特性/任务的不同阶段、两面或后续进展，合并保留一份不丢实质信息。相邻但独立不算：两条各自成立、合并会丢失各自信息（如命名澄清 vs 机制对照、修不同 bug 的相邻提交、不同仓库的两次发版）。',
+].join('\n')
+
+const PAIR_CRITERIA = {
+  true: '同一问题——两条记录的是同一件事的不同阶段/两面/后续进展，合并保留一份不丢实质信息',
+  false: '相邻但独立——各自成立，合并会丢失各自信息（如命名澄清 vs 机制对照、修不同 bug、不同仓库发版）',
+}
+
+// Cluster-level 「值得动吗」 — v1 records it only, never gates (design §2:
+// 簇级问只记不门控，无扫描数据).
+const CLUSTER_CRITERIA = {
+  true: '值得整理——簇内存在值得动作的条目（重复可并、draft 已稳定、已被取代、元数据失准），动作有实质收益',
+  false: '不值得动——条目各自成立，或任何整理动作都不会带来实质收益',
+}
+
+/** Pair question body — the sweep's mrgInstructions: two sides of
+ *  title/tags/conclusion excerpt (ClusterEntry.conclusion is already capped
+ *  at CONCLUSION_SNIPPET_CHARS = the sweep's 600-char protocol). */
+function pairInstructions(a: ClusterEntry, b: ClusterEntry): string {
+  const side = (t: ClusterEntry, name: string): string =>
+    [`## topic ${name}`, `- title: ${t.title}`, `- tags: ${t.tags.join(', ')}`, '- conclusion:', t.conclusion].join('\n')
+  return [side(a, 'A'), '', side(b, 'B'), '', '综合以上材料判断：这两个 topic 讲的是同一个问题、应当合并吗？'].join('\n')
+}
+
+/** Cluster-level question body — titles/status/tags only, no conclusions. */
+function clusterInstructions(cluster: TopicCluster): string {
+  const lines = cluster.entries.map((e) => `- ${e.title}（${e.status}，tags: ${e.tags.join(', ')}）`)
+  return [
+    '## 候选簇内的 topic',
+    ...lines,
+    '',
+    '综合以上材料判断：这一簇值得一次整理动作吗（merge/promote/deprecate/refresh 任一）？',
+  ].join('\n')
+}
+
+/**
+ * The prefilter's jev config slice — undefined unless jevEnabled is explicitly
+ * true (default-off master switch: false ⇒ the whole branch is dead code and
+ * today's behavior runs untouched). Optional keys fall back to their
+ * documented defaults (config.ts: the bare-harness DEFAULTS literal predates
+ * them; consumers treat undefined as the default).
+ */
+function jevConfigOf(cfg: TopicsConfigValue): JevAskConfig | undefined {
+  if (cfg.jevEnabled !== true) return undefined
+  return {
+    jevBackend: cfg.jevBackend ?? 'zen',
+    jevModel: cfg.jevModel ?? '',
+    jevTimeoutMs: cfg.jevTimeoutMs ?? 3000,
+    jevSecretFile: cfg.jevSecretFile ?? '',
+  }
+}
+
+/** The jev seam — injectable so tests run hermetic (same pattern as
+ *  ModelCaller: production never passes it, the real jevAsk is the default). */
+export type JevAsker = typeof jevAsk
+
 // --- Deprecated-TTL housekeeping (local rule, no model) ----------------------
 
 /**
@@ -257,6 +373,14 @@ interface ClusterOutcome {
   ops: ConsolidateOp[]
 }
 
+/** Per-cluster prefilter verdict. */
+interface PrefilterOutcome {
+  /** false = every pair missed the adopt band ⇒ the LLM call is skipped. */
+  proceed: boolean
+  /** jev failed or a gate question had no usable score ⇒ fail-open path. */
+  failOpen: boolean
+}
+
 interface AppliedConsolidation {
   merged: string[]
   promoted: string[]
@@ -270,10 +394,21 @@ export class Consolidator {
   private inFlight: Promise<ConsolidateResult> | undefined
   private readonly service: TopicsService
   private readonly caller: ModelCaller | undefined
+  private readonly askJev: JevAsker
+  /** Best-effort host-logger sink (warn-style); undefined = stay silent,
+   *  aligned with the lane's quiet discipline for success/no-clusters. */
+  private readonly note: ((message: string) => void) | undefined
 
-  constructor(service: TopicsService, caller: ModelCaller | undefined) {
+  constructor(
+    service: TopicsService,
+    caller: ModelCaller | undefined,
+    askJev: JevAsker = jevAsk,
+    note?: (message: string) => void,
+  ) {
     this.service = service
     this.caller = caller
+    this.askJev = askJev
+    this.note = note
   }
 
   get configured(): boolean {
@@ -356,8 +491,23 @@ export class Consolidator {
     let evaluated = 0
     let fatal: 'model-error' | 'invalid-output' | undefined
     let failureDetail: string | undefined
+    // jev prefilter (design §2): one cheap System One batch decides whether a
+    // cluster is worth the LLM call at all. undefined = jevEnabled off ⇒ the
+    // whole branch never executes and behavior is exactly as before.
+    const jev = jevConfigOf(this.service.cfg)
+    let prefilterSkipped = 0
     for (const cluster of clusters) {
       if (calls >= MAX_MODEL_CALLS_PER_RUN) break
+      if (jev !== undefined) {
+        const pf = await this.prefilterCluster(jev, cluster)
+        if (!pf.proceed) {
+          prefilterSkipped += 1
+          this.note?.(
+            `topics consolidate: 前置过滤跳过簇（pair 均未达 adopt 线）：${cluster.entries.map((e) => e.slug).join('、')}`,
+          )
+          continue
+        }
+      }
       const outcome = await this.runCluster(sessionId, cluster)
       calls += 1
       if (outcome.fatal !== undefined) {
@@ -411,6 +561,7 @@ export class Consolidator {
     const tail = [
       applied.dropped > 0 ? `丢弃 ${applied.dropped} 个无效 op` : undefined,
       `${calls} 次模型调用（评估 ${evaluated} 簇 / 候选 ${clusters.length} 簇）`,
+      prefilterSkipped > 0 ? `前置过滤跳过 ${prefilterSkipped} 簇` : undefined,
       fatal !== undefined ? `中途失败：${failureDetail ?? 'unknown'}` : undefined,
       stampNote === '' ? undefined : stampNote.replace(/^；/, ''),
     ]
@@ -455,6 +606,92 @@ export class Consolidator {
     return clusterTopics(entries).slice(0, MAX_MODEL_CALLS_PER_RUN)
   }
 
+  /**
+   * One jev request per cluster (design 2026-09-25 §2 整理 lane 前置). The
+   * top-k similar pairs (k ≤ {@link PREFILTER_TOP_PAIRS}, edges reused from
+   * clustering) each get a pair noul question 「同一问题吗」; one record-only
+   * cluster-level 「值得动吗」 rides along (固定 band='record', never gates).
+   * Gate: ≥1 pair in the adopt band → the cluster goes to the LLM; all pairs
+   * below → skipped (省调用). Any jev failure proceeds fail-open — the
+   * call-layer telemetry row (outcome !== 'ok' marks the fail-open) was already written by jevAsk
+   * itself; only the verdict layer is ours here (agree='n/a', nothing lexical
+   * to reconcile against on this lane).
+   */
+  private async prefilterCluster(jev: JevAskConfig, cluster: TopicCluster): Promise<PrefilterOutcome> {
+    const pairs = cluster.pairs.slice(0, PREFILTER_TOP_PAIRS)
+    // No local similarity evidence (e.g. a capped cluster whose edges all
+    // fell outside) — behave exactly as today, zero jev calls.
+    if (pairs.length === 0) return { proceed: true, failOpen: false }
+    const questions: Record<string, JevQuestion> = {}
+    interface QuestionMeta {
+      questionId: string
+      ref: string
+      instructions: string
+      /** Pair questions gate; the cluster-level question records only. */
+      gating: boolean
+    }
+    const metas: QuestionMeta[] = []
+    pairs.forEach((p, idx) => {
+      const a = cluster.entries[p.i]
+      const b = cluster.entries[p.j]
+      const instructions = pairInstructions(a, b)
+      const questionId = `p${idx + 1}`
+      questions[questionId] = { type: 'noul', instructions, criteria: PAIR_CRITERIA }
+      metas.push({ questionId, ref: `pair:${a.slug}|${b.slug}`, instructions, gating: true })
+    })
+    const clusterQuestion = clusterInstructions(cluster)
+    questions['cluster'] = { type: 'noul', instructions: clusterQuestion, criteria: CLUSTER_CRITERIA }
+    metas.push({
+      questionId: 'cluster',
+      ref: `cluster:${cluster.entries[0]?.slug ?? ''}`,
+      instructions: clusterQuestion,
+      gating: false,
+    })
+
+    const r = await this.askJev({
+      state: PREFILTER_STATE,
+      questions,
+      config: jev,
+      lane: 'consolidate-prefilter',
+      fallback: false,
+      // fallback stays FALSE at call time (jevAsk writes before the outcome
+      // is known); fail-open occurrence = outcome !== 'ok' — this lane's
+      // "cluster goes to the LLM as today" is deterministic per ADR 0018.
+    })
+    if (!r.ok) return { proceed: true, failOpen: true }
+    const at = new Date().toISOString()
+    const recs: JevVerdictRecord[] = []
+    let adopt = false
+    let failOpen = false
+    for (const meta of metas) {
+      // Answer shape per the sweep protocol: noul answers carry the
+      // probability on the `noul` field; anything else is unusable.
+      const raw = (r.answers[meta.questionId] as { noul?: unknown } | undefined)?.noul
+      if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        // A gate question without a usable score must never veto the cluster.
+        if (meta.gating) failOpen = true
+        continue
+      }
+      const probability = Math.min(1, Math.max(0, raw))
+      const verdictBand: JevBand = meta.gating ? band(probability, 'mergePair') : 'record'
+      if (verdictBand === 'adopt') adopt = true
+      recs.push({
+        at,
+        lane: 'consolidate-prefilter',
+        questionId: meta.questionId,
+        qtype: 'noul',
+        ref: meta.ref,
+        digest: digestFor(PREFILTER_STATE, meta.questionId, meta.instructions),
+        probability,
+        band: verdictBand,
+        agree: 'n/a',
+      })
+    }
+    await logVerdicts(recs)
+    if (failOpen) return { proceed: true, failOpen: true }
+    return { proceed: adopt, failOpen: false }
+  }
+
   /** One model call over one cluster, ops shape-validated but not yet applied. */
   private async runCluster(sessionId: string | undefined, cluster: TopicCluster): Promise<ClusterOutcome> {
     const caller = this.caller