@vellumai/assistant 0.7.1 → 0.7.3

package/src/memory/context-search/agent-protocol.ts

@@ -4,13 +4,13 @@ import type { RecallEvidence, RecallSource } from "./types.js";
 
 export type RecallAgentConfidence = "high" | "medium" | "low";
 
-export interface RecallAgentToolDefinition {
+interface RecallAgentToolDefinition {
   name: string;
   description: string;
   input_schema: Record<string, unknown>;
 }
 
-export interface RecallAgentPromptOptions {
+interface RecallAgentPromptOptions {
   query: string;
   availableSources?: readonly RecallSource[];
   evidence: readonly RecallEvidence[];
@@ -18,7 +18,7 @@ export interface RecallAgentPromptOptions {
   maxSearchCalls?: number;
 }
 
-export interface RecallAgentPromptBundle {
+interface RecallAgentPromptBundle {
   prompt: string;
   evidence: RecallEvidence[];
 }
@@ -30,14 +30,14 @@ export interface RecallAgentFinish {
   unresolved?: string[];
 }
 
-export type RecallFinishFallbackReason =
+type RecallFinishFallbackReason =
   | "malformed_finish_payload"
   | "invalid_confidence"
   | "invalid_citation_ids"
   | "unknown_citation_ids"
   | "empty_answer";
 
-export type RecallFinishValidationResult =
+type RecallFinishValidationResult =
   | { ok: true; finish: RecallAgentFinish }
   | {
       ok: false;
@@ -46,7 +46,7 @@ export type RecallFinishValidationResult =
       missingCitationIds?: string[];
     };
 
-export interface RecallCitationValidationResult {
+interface RecallCitationValidationResult {
   ok: boolean;
   validCitationIds: string[];
   missingCitationIds: string[];

package/src/memory/context-search/agent-runner.ts

@@ -5,6 +5,7 @@ import type {
   ProviderResponse,
   ToolUseContent,
 } from "../../providers/types.js";
+import { redactSecrets } from "../../security/secret-scanner.js";
 import {
   buildRecallAgentPromptBundle,
   FINISH_RECALL_TOOL_DEFINITION,
@@ -42,7 +43,7 @@ import type {
   RecallSource,
 } from "./types.js";
 
-export type AgenticRecallFallbackReason =
+type AgenticRecallFallbackReason =
   | "no_provider"
   | "provider_error"
   | "timeout"
@@ -51,7 +52,7 @@ export type AgenticRecallFallbackReason =
   | "citation_validation_failed"
   | "finish_answer_validation_failed";
 
-export interface AgenticRecallSearchDebug {
+interface AgenticRecallSearchDebug {
   round: number;
   query: string;
   sources: RecallSource[];
@@ -61,7 +62,7 @@ export interface AgenticRecallSearchDebug {
   error?: string;
 }
 
-export interface AgenticRecallInspectDebug {
+interface AgenticRecallInspectDebug {
   round: number;
   paths: string[];
   reason: string;
@@ -69,7 +70,7 @@ export interface AgenticRecallInspectDebug {
   errors?: Array<{ path: string; reason: string }>;
 }
 
-export interface AgenticRecallDebug {
+interface AgenticRecallDebug {
   mode: "agentic" | "deterministic_fallback";
   normalizedInput: NormalizedRecallInput;
   roundLimit: number;
@@ -86,12 +87,12 @@ export interface AgenticRecallDebug {
   fallbackDetail?: string;
 }
 
-export interface AgenticRecallAnswer extends RecallAnswer {
+interface AgenticRecallAnswer extends RecallAnswer {
   content: string;
   debug: AgenticRecallDebug;
 }
 
-export interface RunAgenticRecallOptions {
+interface RunAgenticRecallOptions {
   searchOptions?: DeterministicRecallSearchOptions;
 }
 
@@ -305,7 +306,17 @@ export async function runAgenticRecall(
         [...RECALL_AGENT_TOOL_DEFINITIONS],
         undefined,
         {
-          config: { callSite: "recall", temperature: 0 },
+          // `thinking: disabled` is required because we set `temperature: 0`
+          // explicitly. Anthropic 400s on `temperature` ≠ 1 whenever thinking
+          // is enabled or in adaptive mode; without this, profiles that
+          // resolve thinking-enabled (Opus 4.x at `effort: high|xhigh`, etc.)
+          // would fail. Recall is tool-call-heavy reasoning where determinism
+          // matters more than extended chain-of-thought.
+          config: {
+            callSite: "recall",
+            temperature: 0,
+            thinking: { type: "disabled" },
+          },
           signal: context.signal,
         },
       );
@@ -414,6 +425,30 @@ export async function runAgenticRecall(
   );
 }
 
+/**
+ * Redact secrets from workspace-sourced evidence excerpts before they are
+ * serialised into a prompt that will be sent to an external LLM provider.
+ *
+ * Memory, PKB, and conversation evidence is already controlled content —
+ * only workspace files can contain arbitrary secrets (API keys, tokens, etc.)
+ * written by the user or by tools. This runs the same pattern-based scanner
+ * used for shell command summaries and approval prompts, replacing any
+ * detected secrets with `<redacted type="…" />` markers.
+ *
+ * The original evidence array is not mutated; citations and local fallback
+ * paths continue to reference unredacted values.
+ */
+export function redactWorkspaceEvidence(
+  evidence: readonly RecallEvidence[],
+): readonly RecallEvidence[] {
+  return evidence.map((item) => {
+    if (item.source !== "workspace") return item;
+    const redacted = redactSecrets(item.excerpt);
+    if (redacted === item.excerpt) return item;
+    return { ...item, excerpt: redacted };
+  });
+}
+
 function buildPromptBundle(
   input: NormalizedRecallInput,
   evidence: readonly RecallEvidence[],
@@ -422,7 +457,7 @@ function buildPromptBundle(
   return buildRecallAgentPromptBundle({
     query: input.query,
     availableSources: input.sources,
-    evidence,
+    evidence: redactWorkspaceEvidence(evidence),
     maxSearchCalls: roundLimit,
   });
 }
@@ -572,7 +607,14 @@ async function tryFinalFinishRecall(options: {
       [FINISH_RECALL_TOOL_DEFINITION],
       undefined,
       {
-        config: { callSite: "recall", temperature: 0 },
+        // `thinking: disabled` required for the same reason as the agent
+        // round above — Anthropic 400s on `temperature` ≠ 1 whenever
+        // thinking is enabled or in adaptive mode.
+        config: {
+          callSite: "recall",
+          temperature: 0,
+          thinking: { type: "disabled" },
+        },
         signal: options.context.signal,
       },
     );

package/src/memory/context-search/sources/conversations.ts

@@ -88,10 +88,7 @@ export async function searchConversationSource(
 
   for (const ftsMatch of ftsMatches) {
     try {
-      rows = mergeConversationRows(
-        rows,
-        searchWithFts(ftsMatch, context.memoryScopeId, queryLimit),
-      );
+      rows = mergeConversationRows(rows, searchWithFts(ftsMatch, queryLimit));
     } catch {
       // Try the next, broader query shape.
     }
@@ -100,7 +97,7 @@ export async function searchConversationSource(
   }
 
   if (rows.length === 0) {
-    rows = searchWithLike(trimmedQuery, context.memoryScopeId, queryLimit);
+    rows = searchWithLike(trimmedQuery, queryLimit);
   }
 
   const sortedRows = rows
@@ -130,7 +127,6 @@ export async function searchConversationSource(
 
 function searchWithFts(
   ftsMatch: string,
-  memoryScopeId: string,
   limit: number,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
@@ -146,14 +142,12 @@ function searchWithFts(
     JOIN messages m ON m.id = messages_fts.message_id
     JOIN conversations c ON c.id = m.conversation_id
     WHERE messages_fts MATCH ?
-      AND c.memory_scope_id = ?
       AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
       AND (c.source IS NULL OR c.source NOT IN (?, ?))
     ORDER BY bm25(messages_fts), m.created_at DESC
     LIMIT ?
     `,
     ftsMatch,
-    memoryScopeId,
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
     limit,
@@ -162,7 +156,6 @@ function searchWithFts(
 
 function searchWithLike(
   query: string,
-  memoryScopeId: string,
   limit: number,
 ): ConversationEvidenceRow[] {
   return rawAll<ConversationEvidenceRow>(
@@ -177,14 +170,12 @@ function searchWithLike(
     FROM messages m
     JOIN conversations c ON c.id = m.conversation_id
     WHERE m.content LIKE ? ESCAPE '\\'
-      AND c.memory_scope_id = ?
       AND (c.conversation_type IS NULL OR c.conversation_type != 'private')
       AND (c.source IS NULL OR c.source NOT IN (?, ?))
     ORDER BY m.created_at DESC
     LIMIT ?
     `,
     buildLikePattern(query),
-    memoryScopeId,
     SUBAGENT_SOURCE,
     AUTO_ANALYSIS_SOURCE,
     limit,

package/src/memory/context-search/sources/memory-v2.ts

@@ -47,10 +47,11 @@ import type {
 } from "../types.js";
 
 /**
- * True when both v2 gates are on. Single source of truth shared by the recall
- * `memory` source (which delegates to v2), the `pkb` source (which
- * short-circuits because v2 absorbs PKB as a read source), and the per-turn
- * PKB injectors (which go silent so v2 owns the read path end-to-end).
+ * True when both v2 gates are on. Single source of truth for whether v2 is
+ * the active memory subsystem — used by recall sources (`memory`, `pkb`),
+ * per-turn injectors, the indexer's v1 graph_extract suppression, and the
+ * v1/v2 maintenance scheduler. The historical name retains "Read" but the
+ * predicate now gates both read and write paths.
  */
 export function isMemoryV2ReadActive(config: AssistantConfig): boolean {
   return (
@@ -62,11 +63,20 @@ export function isMemoryV2ReadActive(config: AssistantConfig): boolean {
 const log = getLogger("context-search-memory-v2-source");
 
 /**
- * Top-K size for the un-restricted ANN candidate query against the v2
- * concept-page collection. Larger than the per-call recall limit so spreading
- * has neighbors to pull in.
+ * Sentinel passed to Qdrant when `config.memory.v2.ann_candidate_limit` is
+ * `null` (unlimited). Qdrant's query API requires an explicit numeric
+ * `limit`, so unlimited is represented as a number large enough that any
+ * realistic concept-page collection is returned in full.
+ *
+ * Why not `Number.MAX_SAFE_INTEGER`: Qdrant's sparse-vector `SearchContext`
+ * pre-allocates `limit * 16` bytes per query, so passing `MAX_SAFE_INTEGER`
+ * triggers a ~144 PB allocation and SIGABRTs the Qdrant process. 1_000_000
+ * is ~16 MB of pre-allocation in Qdrant — generous headroom over realistic
+ * concept-page counts (low thousands today) while staying well clear of
+ * the OOM cliff. Bump explicitly via `ann_candidate_limit` if you ever
+ * outgrow it.
  */
-const MEMORY_V2_ANN_CANDIDATE_LIMIT = 50;
+const UNLIMITED_ANN_CANDIDATE_LIMIT = 1_000_000;
 
 /** Cap individual concept-page files we are willing to read for lexical scan. */
 const MEMORY_V2_LEXICAL_MAX_FILE_SIZE_BYTES = 256 * 1024;
@@ -181,10 +191,13 @@ async function activationEvidence(
   if (!denseVector || denseVector.length === 0) return [];
   const sparseVector = generateSparseEmbedding(trimmedQuery);
 
+  const annLimit =
+    context.config.memory.v2.ann_candidate_limit ??
+    UNLIMITED_ANN_CANDIDATE_LIMIT;
   const hits = await hybridQueryConceptPages(
     denseVector,
     sparseVector,
-    MEMORY_V2_ANN_CANDIDATE_LIMIT,
+    annLimit,
   );
   if (hits.length === 0) return [];
 

package/src/memory/context-search/sources/memory.ts

@@ -47,7 +47,6 @@ export async function searchMemorySource(
     const searchResults = await searchGraphNodes(
       queryVector,
       normalizedLimit,
-      [context.memoryScopeId],
       sparseVector,
     );
 

package/src/memory/context-search/types.ts

@@ -24,7 +24,6 @@ export interface RecallEvidence {
 
 export interface RecallSearchContext {
   workingDir: string;
-  memoryScopeId: string;
   conversationId: string;
   config: AssistantConfig;
   signal?: AbortSignal;

package/src/memory/conversation-crud.ts

@@ -32,7 +32,7 @@ import {
   deleteOrphanAttachments,
   linkAttachmentToMessage,
 } from "./attachments-store.js";
-import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-guard.js";
+import { AUTO_ANALYSIS_SOURCE } from "./auto-analysis-constants.js";
 import {
   projectAssistantMessage,
   seedForkedConversationAttention,
@@ -115,8 +115,6 @@ export const messageMetadataSchema = z
   })
   .passthrough();
 
-export type MessageMetadata = z.infer<typeof messageMetadataSchema>;
-
 function cloneForkMessageMetadata(
   metadata: string | null,
   sourceMessageId: string,
@@ -444,11 +442,6 @@ export function getConversationSource(conversationId: string): string | null {
   return row?.source ?? null;
 }
 
-export function getConversationMemoryScopeId(conversationId: string): string {
-  const conv = getConversation(conversationId);
-  return conv?.memoryScopeId ?? "default";
-}
-
 /**
  * Fetch group_id for a conversation via raw SQL. group_id is NOT in the
  * Drizzle schema (raw-query-only pattern), so ConversationRow doesn't
@@ -912,7 +905,6 @@ export async function addMessage(
   if (!opts?.skipIndexing) {
     try {
       const config = getConfig();
-      const scopeId = getConversationMemoryScopeId(conversationId);
       const parsed = metadata
         ? messageMetadataSchema.safeParse(metadata)
         : null;
@@ -927,7 +919,7 @@ export async function addMessage(
           role: message.role,
           content: message.content,
           createdAt: message.createdAt,
-          scopeId,
+          scopeId: "default",
           provenanceTrustClass,
           automated,
         },
@@ -1027,7 +1019,7 @@ export function hasMessages(conversationId: string): boolean {
   return row !== undefined;
 }
 
-export interface PaginatedMessagesResult {
+interface PaginatedMessagesResult {
   messages: MessageRow[];
   hasMore: boolean;
 }
@@ -1441,12 +1433,12 @@ export function deleteLastExchange(conversationId: string): number {
  * Callers must delete these from the Qdrant collection after the
  * SQLite transaction commits.
  */
-export interface DeletedMemoryIds {
+interface DeletedMemoryIds {
   segmentIds: string[];
   deletedSummaryIds: string[];
 }
 
-export interface WipeConversationResult extends DeletedMemoryIds {
+interface WipeConversationResult extends DeletedMemoryIds {
   cancelledJobCount: number;
 }
 

package/src/memory/conversation-key-store.ts

@@ -7,20 +7,15 @@
  * first contact.
  */
 
-import { existsSync, unlinkSync } from "node:fs";
-
 import { eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getLogger } from "../util/logger.js";
-import { getWorkspacePromptPath } from "../util/platform.js";
+import { cleanupBootstrapFiles } from "../prompts/bootstrap-cleanup.js";
 import { initConversationDir } from "./conversation-disk-view.js";
 import { GENERATING_TITLE } from "./conversation-title-service.js";
 import { getDb } from "./db-connection.js";
 import { conversationKeys, conversations } from "./schema.js";
 
-const log = getLogger("conversation-key-store");
-
 /** Set after the first conversation is created so BOOTSTRAP.md is deleted on the second. */
 let firstConversationSeen = false;
 
@@ -204,15 +199,7 @@ export function getOrCreateConversation(
     // for its entire duration. Any subsequent conversation means
     // onboarding is over.
     if (firstConversationSeen) {
-      const bp = getWorkspacePromptPath("BOOTSTRAP.md");
-      if (existsSync(bp)) {
-        try {
-          unlinkSync(bp);
-          log.info("Deleted BOOTSTRAP.md — onboarding conversation ended");
-        } catch {
-          // Best-effort
-        }
-      }
+      cleanupBootstrapFiles("new conversation created after onboarding");
     }
     firstConversationSeen = true;
 

package/src/memory/db-init.ts

@@ -102,6 +102,7 @@ import {
   migrateGuardianTimestampsEpochMs,
   migrateGuardianVerificationPurpose,
   migrateGuardianVerificationSessions,
+  migrateHeartbeatRuns,
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
   migrateLlmRequestLogMessageId,
@@ -153,6 +154,7 @@ import {
   migrateRenameVoiceToPhone,
   migrateScheduleOneShotRouting,
   migrateScheduleQuietFlag,
+  migrateScheduleRetryPolicy,
   migrateScheduleReuseConversation,
   migrateScheduleScriptColumn,
   migrateScheduleWakeConversationId,
@@ -163,6 +165,7 @@ import {
   migrateStripPlaceholderSentinelsFromMessages,
   migrateStripThinkingFromConsolidated,
   migrateToolInvocationsMatchedRuleId,
+  migrateTraceEventsCreatedAtIndex,
   migrateUsageDashboardIndexes,
   migrateUsageLlmCallCount,
   migrateVoiceInviteColumns,
@@ -401,9 +404,12 @@ export function initializeDb(): void {
     migrateLlmUsageAttribution,
     migrateSlackCompactionWatermark,
     migrateToolInvocationsMatchedRuleId,
+    migrateHeartbeatRuns,
     function migrateBackfillAppConversationIds() {
       backfillAppConversationIds();
     },
+    migrateScheduleRetryPolicy,
+    migrateTraceEventsCreatedAtIndex,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/embedding-backend.ts

@@ -21,6 +21,7 @@ import {
   type SparseEmbedding,
   type TextEmbeddingInput,
 } from "./embedding-types.js";
+import { SPARSE_VOCAB_SIZE, tokenHash, tokenize } from "./sparse-tokenize.js";
 
 export type { EmbeddingInput, MultimodalEmbeddingInput, TextEmbeddingInput };
 
@@ -787,31 +788,18 @@ async function isOllamaConfigured(config: AssistantConfig): Promise<boolean> {
 // Simple tokenizer + TF-IDF sparse encoder. Produces a SparseEmbedding
 // with term indices (hashed to a fixed vocabulary) and TF-IDF weights.
 // Can be upgraded to a learned sparse encoder (e.g. SPLADE) later.
-
-const SPARSE_VOCAB_SIZE = 30_000;
+// Tokenization primitives (`tokenize`, `tokenHash`, `SPARSE_VOCAB_SIZE`) live
+// in `./sparse-tokenize.ts` so the BM25 encoder can share them without
+// transitively depending on this module.
 
 /**
  * Bump this version whenever the sparse embedding algorithm changes
- * (e.g. hash function fix, tokenizer change) to trigger re-indexing
- * of existing sparse vectors via the sentinel mismatch mechanism.
+ * (e.g. hash function fix, tokenizer change). Now inert metadata — the v1
+ * Qdrant sentinel was decoupled from this constant, so a bump no longer
+ * forces an automatic rebuild. Operators must explicitly run
+ * `assistant memory v2 reembed` to rematerialize the v2 sparse index.
  */
-export const SPARSE_EMBEDDING_VERSION = 2;
-
-/** Tokenize text into lowercase alphanumeric tokens (Unicode-aware). */
-function tokenize(text: string): string[] {
-  return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
-}
-
-/** Hash a token to a stable index in [0, vocabSize). */
-function tokenHash(token: string, vocabSize: number): number {
-  // FNV-1a 32-bit hash for speed
-  let hash = 0x811c9dc5;
-  for (let i = 0; i < token.length; i++) {
-    hash ^= token.charCodeAt(i);
-    hash = Math.imul(hash, 0x01000193) >>> 0;
-  }
-  return hash % vocabSize;
-}
+export const SPARSE_EMBEDDING_VERSION = 4;
 
 /**
  * Generate a TF-IDF-based sparse embedding for the given text.

package/src/memory/embedding-runtime-manager.ts

@@ -38,10 +38,16 @@ const ONNXRUNTIME_COMMON_VERSION = "1.21.0";
 const TRANSFORMERS_VERSION = "3.8.1";
 const JINJA_VERSION = "0.5.5";
 
-/** Composite version string for cache invalidation. */
-const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}`;
+/**
+ * Composite version string for cache invalidation. Bumping the trailing
+ * `_workers-vN` suffix forces existing installs to regenerate the worker
+ * scripts when the worker IPC contract or spawn-args list changes (without
+ * requiring an `@huggingface/transformers` version bump).
+ */
+const RUNTIME_VERSION = `ort-${ONNXRUNTIME_NODE_VERSION}_hf-${TRANSFORMERS_VERSION}_jinja-${JINJA_VERSION}_workers-v2`;
 
 const WORKER_FILENAME = "embed-worker.mjs";
+const RERANK_WORKER_FILENAME = "rerank-worker.mjs";
 
 /** Module-level guard so concurrent in-process calls share one download. */
 const installGuard = new PromiseGuard<void>();
@@ -171,6 +177,101 @@ process.stdin.on('end', () => process.exit(0));
 `;
 }
 
+function generateRerankWorkerScript(): string {
+  // Cross-encoder rerank worker. Loads a sequence-classification model and
+  // scores paired (queries[i], passages[i]) tuples in one batched ONNX
+  // inference call. Mirrors the embed worker's lifecycle (ready signal,
+  // JSON-lines IPC, sequential queue) so LocalRerankBackend can reuse the
+  // same supervisor pattern.
+  //
+  // Request shape: { id, queries: string[], passages: string[] } with
+  // queries.length === passages.length. Each pair is one (query, passage)
+  // tuple; multiple distinct queries can ride in a single batch so the
+  // activation pipeline can score the user-channel and assistant-channel
+  // queries against a shared candidate set in one tokenizer + ONNX call.
+  return `\
+// rerank-worker.mjs — Auto-generated by EmbeddingRuntimeManager
+// Runs in a separate bun process, communicates via JSON-lines over stdin/stdout.
+process.title = 'rerank-worker';
+import {
+  AutoModelForSequenceClassification,
+  AutoTokenizer,
+  env,
+} from '@huggingface/transformers';
+
+const model = process.argv[2];
+const cacheDir = process.argv[3];
+const dtype = process.argv[4] || 'q8';
+if (cacheDir && env) env.cacheDir = cacheDir;
+
+let tokenizer;
+let session;
+try {
+  tokenizer = await AutoTokenizer.from_pretrained(model);
+  session = await AutoModelForSequenceClassification.from_pretrained(model, { dtype });
+  process.stdout.write(JSON.stringify({ type: 'ready' }) + '\\n');
+} catch (err) {
+  process.stdout.write(JSON.stringify({ type: 'error', error: err.message || String(err) }) + '\\n');
+  process.exit(1);
+}
+
+const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+
+const decoder = new TextDecoder();
+let buffer = '';
+let processing = false;
+const queue = [];
+
+process.stdin.on('data', (chunk) => {
+  buffer += typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
+  let idx;
+  while ((idx = buffer.indexOf('\\n')) !== -1) {
+    const line = buffer.slice(0, idx);
+    buffer = buffer.slice(idx + 1);
+    if (line.trim()) queue.push(line);
+  }
+  if (!processing) processQueue();
+});
+
+async function processQueue() {
+  processing = true;
+  while (queue.length > 0) {
+    const line = queue.shift();
+    let req;
+    try { req = JSON.parse(line); } catch { continue; }
+    try {
+      const { id, queries, passages } = req;
+      if (
+        !Array.isArray(queries) || !Array.isArray(passages) ||
+        queries.length !== passages.length || passages.length === 0
+      ) {
+        process.stdout.write(JSON.stringify({ id, scores: [] }) + '\\n');
+        continue;
+      }
+      const inputs = await tokenizer(queries, {
+        text_pair: passages,
+        padding: true,
+        truncation: true,
+        return_tensors: 'pt',
+      });
+      const out = await session(inputs);
+      const logits = out.logits.data;
+      const scores = new Array(passages.length);
+      for (let i = 0; i < passages.length; i++) {
+        scores[i] = sigmoid(Number(logits[i]));
+      }
+      process.stdout.write(JSON.stringify({ id, scores }) + '\\n');
+    } catch (err) {
+      process.stdout.write(JSON.stringify({ id: req?.id, error: err.message || String(err) }) + '\\n');
+    }
+  }
+  processing = false;
+}
+
+process.stdin.on('end', () => process.exit(0));
+`;
+}
+
 // ── Main manager ────────────────────────────────────────────────────
 
 export class EmbeddingRuntimeManager {
@@ -186,8 +287,12 @@ export class EmbeddingRuntimeManager {
     if (!manifest) return false;
     if (manifest.runtimeVersion !== RUNTIME_VERSION) return false;
 
-    // Verify the worker script exists and a bun binary is available
-    return existsSync(this.getWorkerPath()) && this.getBunPath() !== undefined;
+    // Verify both worker scripts exist and a bun binary is available
+    return (
+      existsSync(this.getWorkerPath()) &&
+      existsSync(this.getRerankWorkerPath()) &&
+      this.getBunPath() !== undefined
+    );
   }
 
   /** Path to the embed worker script. */
@@ -195,6 +300,11 @@ export class EmbeddingRuntimeManager {
     return join(this.baseDir, WORKER_FILENAME);
   }
 
+  /** Path to the rerank worker script. */
+  getRerankWorkerPath(): string {
+    return join(this.baseDir, RERANK_WORKER_FILENAME);
+  }
+
   /**
    * Find a usable bun binary.
    * Delegates to the shared bun-runtime helper, also checking
@@ -375,8 +485,12 @@ export class EmbeddingRuntimeManager {
         ].join("\n"),
       );
 
-      // Step 4: Write embed worker script
+      // Step 4: Write embed + rerank worker scripts
       writeFileSync(join(tmpDir, WORKER_FILENAME), generateWorkerScript());
+      writeFileSync(
+        join(tmpDir, RERANK_WORKER_FILENAME),
+        generateRerankWorkerScript(),
+      );
 
       // Step 5: Write version manifest
       const manifest: VersionManifest = {