agent-working-memory 0.17.0 → 0.19.0

package/src/core/query-expander.ts

@@ -1,126 +1,127 @@
-// Copyright 2026 Robert Winter / Complete Ideas
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Query Expander - rewrites queries with synonyms and related terms.
- *
- * Uses Xenova/flan-t5-small — a 141MB encoder plus a 233MB merged decoder, so
- * 374MB of ONNX and a 377MB download with its tokenizer. By far the largest of
- * the three models AWM fetches. Expands search queries with related terms that
- * improve BM25 recall.
- *
- * AWM 0.8.x: inference dispatches through ml-worker.ts (currently in-process
- * — worker_threads reverted because onnxruntime-node bindings cross isolate
- * boundaries unsafely; see ml-worker.ts). The dispatch abstraction is
- * preserved for a future child_process / HTTP sidecar pool.
- *
- * The LRU cache + skip heuristic stay on the main thread — they're pure
- * filter/lookup logic that shouldn't pay IPC cost.
- */
-
-import { pipeline, type Text2TextGenerationPipeline } from '@huggingface/transformers';
-import { dispatchExpand, registerInProcessHandlers } from './ml-worker.js';
-import { ensureModelCacheDir } from './model-cache.js';
-
-const MODEL_ID = 'Xenova/flan-t5-small';
-
-// --- In-process fallback ---
-
-let inProcessInstance: Text2TextGenerationPipeline | null = null;
-let inProcessInitPromise: Promise<Text2TextGenerationPipeline> | null = null;
-
-async function loadInProcess(): Promise<Text2TextGenerationPipeline> {
-  if (inProcessInstance) return inProcessInstance;
-  if (inProcessInitPromise) return inProcessInitPromise;
-  ensureModelCacheDir();
-  inProcessInitPromise = pipeline('text2text-generation', MODEL_ID, { dtype: 'fp32' }).then(pipe => {
-    inProcessInstance = pipe as Text2TextGenerationPipeline;
-    console.error(`Query expander loaded in-process: ${MODEL_ID}`);
-    return inProcessInstance;
-  });
-  return inProcessInitPromise;
-}
-
-async function inProcessExpand(args: { prompt: string; maxNewTokens: number; noRepeatNgramSize: number }): Promise<string> {
-  const expander = await loadInProcess();
-  const result = await expander(args.prompt, {
-    max_new_tokens: args.maxNewTokens,
-    no_repeat_ngram_size: args.noRepeatNgramSize,
-  });
-  const text = Array.isArray(result) ? (result[0] as any)?.generated_text ?? '' : '';
-  return String(text).trim();
-}
-
-registerInProcessHandlers({ expand: inProcessExpand });
-
-// --- Public API ---
-
-/** Kept for backwards compat. */
-export async function getExpander(): Promise<Text2TextGenerationPipeline> {
-  return loadInProcess();
-}
-
-/**
- * LRU cache of normalized-query → expanded-query mappings.
- * Lives on the main thread — cache hits skip the worker IPC entirely.
- */
-const expansionCache = new Map<string, string>();
-const EXPANSION_CACHE_LIMIT = 500;
-
-/**
- * Skip expansion when the query is already specific (long or many tokens).
- */
-function shouldSkipExpansion(normalized: string): boolean {
-  if (normalized.length === 0) return true;
-  if (normalized.length > 50) return true;
-  const tokens = new Set(normalized.split(/\s+/).filter(t => t.length > 2));
-  return tokens.size >= 5;
-}
-
-/**
- * Expand a query with related terms and synonyms.
- * Returns the original query + generated expansion terms.
- * Falls back to the original query on any error.
- *
- * Dispatches inference to the worker pool. Cache + skip heuristic stay
- * on the main thread.
- */
-export async function expandQuery(originalQuery: string): Promise<string> {
-  const normalized = originalQuery.toLowerCase().trim();
-  const optimizationsEnabled = process.env.AWM_DISABLE_EXPANSION_CACHE !== '1';
-
-  if (optimizationsEnabled) {
-    if (shouldSkipExpansion(normalized)) return originalQuery;
-    const cached = expansionCache.get(normalized);
-    if (cached !== undefined) {
-      // LRU touch
-      expansionCache.delete(normalized);
-      expansionCache.set(normalized, cached);
-      return cached;
-    }
-  }
-
-  try {
-    const prompt = `Expand this search query with synonyms and related terms. Only output the additional terms, not the original query. Query: ${originalQuery}. Additional terms:`;
-    const expansion = await dispatchExpand({ prompt, maxNewTokens: 25, noRepeatNgramSize: 2 });
-    const finalQuery = expansion && expansion.length > 2
-      ? `${originalQuery} ${expansion}`
-      : originalQuery;
-
-    if (optimizationsEnabled) {
-      if (expansionCache.size >= EXPANSION_CACHE_LIMIT) {
-        const oldestKey = expansionCache.keys().next().value;
-        if (oldestKey !== undefined) expansionCache.delete(oldestKey);
-      }
-      expansionCache.set(normalized, finalQuery);
-    }
-
-    return finalQuery;
-  } catch {
-    return originalQuery;
-  }
-}
-
-/** Clear the expansion cache (used by tests + cache invalidation). */
-export function clearExpansionCache(): void {
-  expansionCache.clear();
-}
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Query Expander - rewrites queries with synonyms and related terms.
+ *
+ * Uses Xenova/flan-t5-small — a 141MB encoder plus a 233MB merged decoder, so
+ * 374MB of ONNX and a 377MB download with its tokenizer. By far the largest of
+ * the three models AWM fetches. Expands search queries with related terms that
+ * improve BM25 recall.
+ *
+ * AWM 0.8.x: inference dispatches through ml-worker.ts (currently in-process
+ * — worker_threads reverted because onnxruntime-node bindings cross isolate
+ * boundaries unsafely; see ml-worker.ts). The dispatch abstraction is
+ * preserved for a future child_process / HTTP sidecar pool.
+ *
+ * The LRU cache + skip heuristic stay on the main thread — they're pure
+ * filter/lookup logic that shouldn't pay IPC cost.
+ */
+
+import { pipeline, type Text2TextGenerationPipeline } from '@huggingface/transformers';
+import { dispatchExpand, registerInferenceConfig, registerInProcessHandlers } from './ml-worker.js';
+import { ensureModelCacheDir } from './model-cache.js';
+
+const MODEL_ID = 'Xenova/flan-t5-small';
+
+// --- In-process fallback ---
+
+let inProcessInstance: Text2TextGenerationPipeline | null = null;
+let inProcessInitPromise: Promise<Text2TextGenerationPipeline> | null = null;
+
+async function loadInProcess(): Promise<Text2TextGenerationPipeline> {
+  if (inProcessInstance) return inProcessInstance;
+  if (inProcessInitPromise) return inProcessInitPromise;
+  ensureModelCacheDir();
+  inProcessInitPromise = pipeline('text2text-generation', MODEL_ID, { dtype: 'fp32' }).then(pipe => {
+    inProcessInstance = pipe as Text2TextGenerationPipeline;
+    console.error(`Query expander loaded in-process: ${MODEL_ID}`);
+    return inProcessInstance;
+  });
+  return inProcessInitPromise;
+}
+
+export async function inProcessExpand(args: { prompt: string; maxNewTokens: number; noRepeatNgramSize: number }): Promise<string> {
+  const expander = await loadInProcess();
+  const result = await expander(args.prompt, {
+    max_new_tokens: args.maxNewTokens,
+    no_repeat_ngram_size: args.noRepeatNgramSize,
+  });
+  const text = Array.isArray(result) ? (result[0] as any)?.generated_text ?? '' : '';
+  return String(text).trim();
+}
+
+registerInProcessHandlers({ expand: inProcessExpand });
+registerInferenceConfig({ expandModel: MODEL_ID });
+
+// --- Public API ---
+
+/** Kept for backwards compat. */
+export async function getExpander(): Promise<Text2TextGenerationPipeline> {
+  return loadInProcess();
+}
+
+/**
+ * LRU cache of normalized-query → expanded-query mappings.
+ * Lives on the main thread — cache hits skip the worker IPC entirely.
+ */
+const expansionCache = new Map<string, string>();
+const EXPANSION_CACHE_LIMIT = 500;
+
+/**
+ * Skip expansion when the query is already specific (long or many tokens).
+ */
+function shouldSkipExpansion(normalized: string): boolean {
+  if (normalized.length === 0) return true;
+  if (normalized.length > 50) return true;
+  const tokens = new Set(normalized.split(/\s+/).filter(t => t.length > 2));
+  return tokens.size >= 5;
+}
+
+/**
+ * Expand a query with related terms and synonyms.
+ * Returns the original query + generated expansion terms.
+ * Falls back to the original query on any error.
+ *
+ * Dispatches inference to the worker pool. Cache + skip heuristic stay
+ * on the main thread.
+ */
+export async function expandQuery(originalQuery: string): Promise<string> {
+  const normalized = originalQuery.toLowerCase().trim();
+  const optimizationsEnabled = process.env.AWM_DISABLE_EXPANSION_CACHE !== '1';
+
+  if (optimizationsEnabled) {
+    if (shouldSkipExpansion(normalized)) return originalQuery;
+    const cached = expansionCache.get(normalized);
+    if (cached !== undefined) {
+      // LRU touch
+      expansionCache.delete(normalized);
+      expansionCache.set(normalized, cached);
+      return cached;
+    }
+  }
+
+  try {
+    const prompt = `Expand this search query with synonyms and related terms. Only output the additional terms, not the original query. Query: ${originalQuery}. Additional terms:`;
+    const expansion = await dispatchExpand({ prompt, maxNewTokens: 25, noRepeatNgramSize: 2 });
+    const finalQuery = expansion && expansion.length > 2
+      ? `${originalQuery} ${expansion}`
+      : originalQuery;
+
+    if (optimizationsEnabled) {
+      if (expansionCache.size >= EXPANSION_CACHE_LIMIT) {
+        const oldestKey = expansionCache.keys().next().value;
+        if (oldestKey !== undefined) expansionCache.delete(oldestKey);
+      }
+      expansionCache.set(normalized, finalQuery);
+    }
+
+    return finalQuery;
+  } catch {
+    return originalQuery;
+  }
+}
+
+/** Clear the expansion cache (used by tests + cache invalidation). */
+export function clearExpansionCache(): void {
+  expansionCache.clear();
+}

package/src/core/recall-config.ts

@@ -45,6 +45,11 @@ export const RECALL_FLAGS = [
   // Omitted until 2026-10-09, during which both arms of a dtype sweep printed the
   // SAME arm= label; the whole point of this list is that that cannot happen.
   'AWM_RERANKER_DTYPE',
+  // ONNX input caps (2026-10-16). The query cap changes scores for queries over the
+  // cap; the batch sizes should not, but they are listed so an arm says them.
+  'AWM_RERANK_QUERY_TOKENS',
+  'AWM_RERANK_BATCH',
+  'AWM_EMBED_BATCH',
   // Derived retrieval text (embedding side)
   'AWM_RETRIEVAL_TEXT',
   // Project-dialect alias expansion

package/src/core/rerank-window.ts

@@ -1,159 +1,164 @@
-// Copyright 2026 Robert Winter / Complete Ideas
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Passage selection for cross-encoder reranking.
- *
- * THE PROBLEM
- * -----------
- * Reranking truncates each passage to a fixed prefix (historically the first
- * 400 chars). That truncation exists for a real reason: cross-encoders pad to
- * the longest passage in the batch, so one 5,000-char memory in a 40-item pool
- * drags every passage to ~512 tokens and costs 3-4x. The reranker is already
- * 83% of warm recall latency (measured, `npm run profile:recall`), so "just send
- * everything" is not available.
- *
- * But a PREFIX is the wrong 400 chars. Measured on the live 29.8k store:
- *   - canonical memories median 1,965 chars, 98.7% exceed 400
- *   - the reranker cannot see 78.8% of each canonical memory's vocabulary
- *   - 99.9% of long canonical memories carry identifiers only past char 400
- * And measured on tests/longmem-eval: moving the answer from char 150 to char
- * 700 takes success@1 from 100% to 0%, with the gold's cross-encoder score
- * collapsing 0.986 -> 0.000 while its BM25 score barely moves. The memory stays
- * retrievable and stops being rankable.
- *
- * THE FIX
- * -------
- * Spend the same character budget on the window that actually contains the
- * query's terms, instead of on whatever happens to be at the top of the memory.
- * Cost is unchanged — same budget, same batch padding, same inference — so this
- * buys ranking quality without buying latency.
- *
- * The concept line is always kept: it is short, it is the memory's title, and
- * it is what a human wrote to summarise the thing.
- */
-
-/** Cheap tokenizer for locating query terms inside a passage. */
-function terms(query: string): string[] {
-  const raw = query.toLowerCase().match(/[a-z0-9_][a-z0-9_.\-]{1,}/g) ?? [];
-  const STOP = new Set([
-    'the', 'and', 'for', 'with', 'that', 'this', 'from', 'what', 'where', 'when',
-    'which', 'does', 'did', 'was', 'were', 'are', 'is', 'be', 'to', 'of', 'in',
-    'on', 'at', 'by', 'it', 'as', 'do', 'how', 'why', 'a', 'an', 'or',
-  ]);
-  return Array.from(new Set(raw.filter(t => t.length >= 3 && !STOP.has(t))));
-}
-
-/**
- * Choose the `budget`-char window of `content` densest in query terms.
- * Returns the head of the content when nothing matches — the old behavior,
- * which is the right fallback: with no query signal there is no reason to
- * prefer any other part of the memory.
- */
-export function densestWindow(content: string, query: string, budget: number): string {
-  if (content.length <= budget) return content;
-
-  const toks = terms(query);
-  if (toks.length === 0) return content.slice(0, budget);
-
-  const lower = content.toLowerCase();
-  const hits: number[] = [];
-  for (const t of toks) {
-    let from = 0;
-    for (;;) {
-      const i = lower.indexOf(t, from);
-      if (i < 0) break;
-      hits.push(i);
-      from = i + t.length;
-    }
-  }
-  if (hits.length === 0) return content.slice(0, budget);
-  hits.sort((a, b) => a - b);
-
-  // Slide a window anchored slightly before each hit; keep the one covering most.
-  let bestStart = 0;
-  let bestCount = -1;
-  for (let i = 0; i < hits.length; i++) {
-    const start = Math.max(0, hits[i] - Math.floor(budget / 5));
-    let count = 0;
-    for (let j = i; j < hits.length && hits[j] - start < budget; j++) count++;
-    if (count > bestCount) { bestCount = count; bestStart = start; }
-  }
-
-  // Snap to a word boundary so the cross-encoder is not handed a split token.
-  let start = bestStart;
-  if (start > 0) {
-    const sp = content.indexOf(' ', start);
-    if (sp >= 0 && sp - start < 40) start = sp + 1;
-  }
-  const slice = content.slice(start, start + budget);
-  return (start > 0 ? '…' : '') + slice + (start + budget < content.length ? '…' : '');
-}
-
-/**
- * Build the passage handed to the cross-encoder for one candidate.
- *
- * `mode`:
- *  - `'prefix'` (default) — legacy behavior, the first `budget` chars.
- *  - `'query'`  — the `budget`-char window densest in query terms.
- */
-export function buildRerankPassage(
-  concept: string,
-  content: string,
-  query: string,
-  budget: number,
-  mode: 'prefix' | 'query',
-  tags?: string[],
-): string {
-  const body = mode === 'query'
-    ? densestWindow(content, query, budget)
-    : (content.length > budget ? content.slice(0, budget) : content);
-  // Topical tags, when enabled. The cross-encoder decides final order since
-  // phase 9b, and it cannot see tags at all — measured on the live store, 66.2%
-  // of topical tag terms never appear in the body, so that vocabulary is
-  // invisible to the stage that now decides ranking. Appended (not substituted)
-  // and length-capped so it cannot crowd out the content window.
-  const extra = rerankTagText(tags);
-  return extra ? `${concept}: ${body} ${extra}` : `${concept}: ${body}`;
-}
-
-/** Whether topical tags are appended to the rerank passage. Default OFF. */
-export function rerankTagsEnabled(): boolean {
-  return process.env.AWM_RERANK_TAGS === '1';
-}
-
-/** Character budget for the appended tag text. */
-export function rerankTagBudget(): number {
-  const v = Number(process.env.AWM_RERANK_TAGS_LEN ?? 80);
-  return Number.isFinite(v) && v > 0 ? v : 80;
-}
-
-/**
- * Render topical tags as plain terms for the cross-encoder.
- * Only `topic=` / `proj=` / `project=` carry query vocabulary; date/person/
- * ticket tags are identifiers the body usually already contains, and adding
- * them would spend the budget without adding reachable words.
- */
-export function rerankTagText(tags?: string[]): string {
-  if (!rerankTagsEnabled() || !tags || tags.length === 0) return '';
-  const words = new Set<string>();
-  for (const t of tags) {
-    const m = /^(?:topic|proj|project)=(.+)$/i.exec(t);
-    if (!m) continue;
-    for (const w of m[1].toLowerCase().split(/[-_\s]+/)) {
-      if (w.length > 2) words.add(w);
-    }
-  }
-  if (words.size === 0) return '';
-  return `[${[...words].join(' ').slice(0, rerankTagBudget())}]`;
-}
-
-/** Character budget for a rerank passage. */
-export function rerankTruncation(): number {
-  const v = Number(process.env.AWM_RERANK_TRUNC ?? 400);
-  return Number.isFinite(v) && v > 0 ? v : 400;
-}
-
-/** Passage selection mode. Default `prefix` preserves shipped behavior. */
-export function rerankWindowMode(): 'prefix' | 'query' {
-  return process.env.AWM_RERANK_WINDOW === 'query' ? 'query' : 'prefix';
-}
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Passage selection for cross-encoder reranking.
+ *
+ * THE PROBLEM
+ * -----------
+ * Reranking truncates each passage to a fixed prefix (historically the first
+ * 400 chars). That truncation exists for a real reason: cross-encoders pad to
+ * the longest passage in the batch, so one 5,000-char memory in a 40-item pool
+ * drags every passage to ~512 tokens and costs 3-4x. The reranker is already
+ * 83% of warm recall latency (measured, `npm run profile:recall`), so "just send
+ * everything" is not available.
+ *
+ * But a PREFIX is the wrong 400 chars. Measured on the live 29.8k store:
+ *   - canonical memories median 1,965 chars, 98.7% exceed 400
+ *   - the reranker cannot see 78.8% of each canonical memory's vocabulary
+ *   - 99.9% of long canonical memories carry identifiers only past char 400
+ * And measured on tests/longmem-eval: moving the answer from char 150 to char
+ * 700 takes success@1 from 100% to 0%, with the gold's cross-encoder score
+ * collapsing 0.986 -> 0.000 while its BM25 score barely moves. The memory stays
+ * retrievable and stops being rankable.
+ *
+ * THE FIX
+ * -------
+ * Spend the same character budget on the window that actually contains the
+ * query's terms, instead of on whatever happens to be at the top of the memory.
+ * Cost is unchanged — same budget, same batch padding, same inference — so this
+ * buys ranking quality without buying latency.
+ *
+ * The concept line is always kept: it is short, it is the memory's title, and
+ * it is what a human wrote to summarise the thing.
+ */
+
+/** Cheap tokenizer for locating query terms inside a passage. */
+function terms(query: string): string[] {
+  const raw = query.toLowerCase().match(/[a-z0-9_][a-z0-9_.\-]{1,}/g) ?? [];
+  const STOP = new Set([
+    'the', 'and', 'for', 'with', 'that', 'this', 'from', 'what', 'where', 'when',
+    'which', 'does', 'did', 'was', 'were', 'are', 'is', 'be', 'to', 'of', 'in',
+    'on', 'at', 'by', 'it', 'as', 'do', 'how', 'why', 'a', 'an', 'or',
+  ]);
+  return Array.from(new Set(raw.filter(t => t.length >= 3 && !STOP.has(t))));
+}
+
+/**
+ * Choose the `budget`-char window of `content` densest in query terms.
+ * Returns the head of the content when nothing matches — the old behavior,
+ * which is the right fallback: with no query signal there is no reason to
+ * prefer any other part of the memory.
+ */
+export function densestWindow(content: string, query: string, budget: number): string {
+  if (content.length <= budget) return content;
+
+  const toks = terms(query);
+  if (toks.length === 0) return content.slice(0, budget);
+
+  const lower = content.toLowerCase();
+  const hits: number[] = [];
+  for (const t of toks) {
+    let from = 0;
+    for (;;) {
+      const i = lower.indexOf(t, from);
+      if (i < 0) break;
+      hits.push(i);
+      from = i + t.length;
+    }
+  }
+  if (hits.length === 0) return content.slice(0, budget);
+  hits.sort((a, b) => a - b);
+
+  // Slide a window anchored slightly before each hit; keep the one covering most.
+  let bestStart = 0;
+  let bestCount = -1;
+  for (let i = 0; i < hits.length; i++) {
+    const start = Math.max(0, hits[i] - Math.floor(budget / 5));
+    let count = 0;
+    for (let j = i; j < hits.length && hits[j] - start < budget; j++) count++;
+    if (count > bestCount) { bestCount = count; bestStart = start; }
+  }
+
+  // Snap to a word boundary so the cross-encoder is not handed a split token.
+  let start = bestStart;
+  if (start > 0) {
+    const sp = content.indexOf(' ', start);
+    if (sp >= 0 && sp - start < 40) start = sp + 1;
+  }
+  const slice = content.slice(start, start + budget);
+  return (start > 0 ? '…' : '') + slice + (start + budget < content.length ? '…' : '');
+}
+
+/**
+ * Build the passage handed to the cross-encoder for one candidate.
+ *
+ * `mode`:
+ *  - `'prefix'` (default) — legacy behavior, the first `budget` chars.
+ *  - `'query'`  — the `budget`-char window densest in query terms.
+ */
+export function buildRerankPassage(
+  concept: string,
+  content: string,
+  query: string,
+  budget: number,
+  mode: 'prefix' | 'query',
+  tags?: string[],
+): string {
+  const body = mode === 'query'
+    ? densestWindow(content, query, budget)
+    : (content.length > budget ? content.slice(0, budget) : content);
+  // Topical tags, when enabled. The cross-encoder decides final order since
+  // phase 9b, and it cannot see tags at all — measured on the live store, 66.2%
+  // of topical tag terms never appear in the body, so that vocabulary is
+  // invisible to the stage that now decides ranking. Appended (not substituted)
+  // and length-capped so it cannot crowd out the content window.
+  const extra = rerankTagText(tags);
+  return extra ? `${concept}: ${body} ${extra}` : `${concept}: ${body}`;
+}
+
+/** Whether topical tags are appended to the rerank passage. Default ON since
+ *  2026-10-19 (+7.4pp s@1 measured 2026-08-24); `AWM_RERANK_TAGS=0` disables.
+ *  See rerank2.ts `rerank2Enabled` for why the measured-good settings became
+ *  code defaults rather than config strings. */
+export function rerankTagsEnabled(): boolean {
+  return process.env.AWM_RERANK_TAGS !== '0';
+}
+
+/** Character budget for the appended tag text. */
+export function rerankTagBudget(): number {
+  const v = Number(process.env.AWM_RERANK_TAGS_LEN ?? 80);
+  return Number.isFinite(v) && v > 0 ? v : 80;
+}
+
+/**
+ * Render topical tags as plain terms for the cross-encoder.
+ * Only `topic=` / `proj=` / `project=` carry query vocabulary; date/person/
+ * ticket tags are identifiers the body usually already contains, and adding
+ * them would spend the budget without adding reachable words.
+ */
+export function rerankTagText(tags?: string[]): string {
+  if (!rerankTagsEnabled() || !tags || tags.length === 0) return '';
+  const words = new Set<string>();
+  for (const t of tags) {
+    const m = /^(?:topic|proj|project)=(.+)$/i.exec(t);
+    if (!m) continue;
+    for (const w of m[1].toLowerCase().split(/[-_\s]+/)) {
+      if (w.length > 2) words.add(w);
+    }
+  }
+  if (words.size === 0) return '';
+  return `[${[...words].join(' ').slice(0, rerankTagBudget())}]`;
+}
+
+/** Character budget for a rerank passage. */
+export function rerankTruncation(): number {
+  const v = Number(process.env.AWM_RERANK_TRUNC ?? 400);
+  return Number.isFinite(v) && v > 0 ? v : 400;
+}
+
+/** Passage selection mode. Default `query` since 2026-10-19 (long-memory s@1
+ *  25% → 87.5%, measured 2026-08-24); `AWM_RERANK_WINDOW=prefix` restores the
+ *  first-N-chars passage. Must ship with rerank2 on, which it now does. */
+export function rerankWindowMode(): 'prefix' | 'query' {
+  return process.env.AWM_RERANK_WINDOW === 'prefix' ? 'prefix' : 'query';
+}