@totalreclaw/totalreclaw 1.6.0 → 3.0.6

package/digest-sync.ts

@@ -0,0 +1,516 @@
+/**
+ * TotalReclaw Plugin — digest read path (Stage 3b).
+ *
+ * Loads the latest digest claim from the subgraph, checks staleness, and
+ * returns the pre-compiled `promptText` for injection into before_agent_start.
+ * Triggers background recompilation (non-blocking) when the digest is stale
+ * and the guard conditions (>=10 new claims OR >=24h) are met.
+ *
+ * The digest is stored on-chain as a regular encrypted fact where the
+ * decrypted content is a canonical Claim with category="dig" and a
+ * distinctive blind-index marker `DIGEST_TRAPDOOR`.
+ */
+
+import { createRequire } from 'node:module';
+import {
+  DIGEST_CLAIM_CAP,
+  DIGEST_TRAPDOOR,
+  buildDigestClaim,
+  extractDigestFromClaim,
+  hoursSince,
+  isDigestStale,
+  shouldRecompile,
+  type DigestMode,
+} from './claims-helper.js';
+
+const requireWasm = createRequire(import.meta.url);
+let _wasm: typeof import('@totalreclaw/core') | null = null;
+function getWasm() {
+  if (!_wasm) _wasm = requireWasm('@totalreclaw/core');
+  return _wasm!;
+}
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface DigestLogger {
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ParsedDigest = any;
+
+export interface LoadedDigest {
+  digest: ParsedDigest;
+  claimId: string;
+  createdAt: number;
+}
+
+export interface EvaluateDigestStateInput {
+  digestVersion: number;
+  currentMaxCreatedAt: number;
+  countNewClaims: number;
+  hoursSinceCompilation: number;
+}
+
+export interface DigestState {
+  stale: boolean;
+  recompile: boolean;
+}
+
+export interface CompileDigestCoreInput {
+  claimsJson: string;
+  nowUnixSeconds: number;
+  mode: DigestMode;
+  /**
+   * Optional LLM invocation. Receives the compiled prompt and must return
+   * the raw model output. Throw on HTTP error or timeout — compileDigestCore
+   * catches and falls back to the template path.
+   */
+  llmFn: ((prompt: string) => Promise<string>) | null;
+  logger: DigestLogger;
+}
+
+// ---------------------------------------------------------------------------
+// Recompile-in-progress guard (in-memory, per-process)
+// ---------------------------------------------------------------------------
+
+let _recompileInProgress = false;
+
+/** Is a digest recompilation currently running for this process? */
+export function isRecompileInProgress(): boolean {
+  return _recompileInProgress;
+}
+
+/** Attempt to acquire the recompile lock. Returns true on success. */
+export function tryBeginRecompile(): boolean {
+  if (_recompileInProgress) return false;
+  _recompileInProgress = true;
+  return true;
+}
+
+/** Release the recompile lock — always call in a finally block. */
+export function endRecompile(): void {
+  _recompileInProgress = false;
+}
+
+/** Test-only helper to reset module state between cases. */
+export function __resetDigestSyncState(): void {
+  _recompileInProgress = false;
+}
+
+// ---------------------------------------------------------------------------
+// Pure staleness + guard evaluation
+// ---------------------------------------------------------------------------
+
+/**
+ * Combine staleness + guard checks into one decision.
+ *
+ * The caller still needs to consult `isRecompileInProgress()` before firing
+ * the background task — this function is purely about the digest's age.
+ */
+export function evaluateDigestState(input: EvaluateDigestStateInput): DigestState {
+  const stale = isDigestStale(input.digestVersion, input.currentMaxCreatedAt);
+  if (!stale) return { stale: false, recompile: false };
+  const recompile = shouldRecompile({
+    countNewClaims: input.countNewClaims,
+    hoursSinceCompilation: input.hoursSinceCompilation,
+  });
+  return { stale: true, recompile };
+}
+
+// ---------------------------------------------------------------------------
+// Core compilation (pure, no I/O)
+// ---------------------------------------------------------------------------
+
+/**
+ * Compile a Digest JSON from an array of Claim JSON.
+ *
+ * - `mode === 'template'` or `llmFn === null` → template path.
+ * - `mode === 'on'` with a non-null `llmFn` → LLM path with template fallback.
+ *   Any parsing/assembly/LLM failure logs a warning and falls back silently.
+ * - Claim count above DIGEST_CLAIM_CAP forces the template path regardless
+ *   of mode, to keep LLM token cost bounded.
+ *
+ * Returns the Digest JSON as produced by the WASM core.
+ */
+export async function compileDigestCore(input: CompileDigestCoreInput): Promise<string> {
+  const { claimsJson, nowUnixSeconds, mode, llmFn, logger } = input;
+  const core = getWasm();
+  const nowBig = BigInt(Math.floor(nowUnixSeconds));
+
+  // Check whether we should even attempt the LLM path.
+  let useLlm = mode === 'on' && llmFn !== null;
+  if (useLlm) {
+    try {
+      const parsedClaims = JSON.parse(claimsJson);
+      if (!Array.isArray(parsedClaims) || parsedClaims.length === 0) {
+        useLlm = false;
+      } else if (parsedClaims.length > DIGEST_CLAIM_CAP) {
+        logger.info(
+          `Digest: ${parsedClaims.length} active claims > cap ${DIGEST_CLAIM_CAP}; using template path`,
+        );
+        useLlm = false;
+      }
+    } catch {
+      useLlm = false;
+    }
+  }
+
+  if (useLlm && llmFn) {
+    try {
+      const prompt = core.buildDigestPrompt(claimsJson);
+      const raw = await llmFn(prompt);
+      if (!raw || typeof raw !== 'string' || raw.trim().length === 0) {
+        throw new Error('LLM returned empty response');
+      }
+      const parsedResponse = core.parseDigestResponse(raw);
+      return core.assembleDigestFromLlm(parsedResponse, claimsJson, nowBig);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn(`Digest LLM compilation failed, falling back to template: ${msg}`);
+      // fall through to template path
+    }
+  }
+
+  return core.buildTemplateDigest(claimsJson, nowBig);
+}
+
+// ---------------------------------------------------------------------------
+// I/O helpers — subgraph reads
+// ---------------------------------------------------------------------------
+
+/**
+ * Find the latest digest claim on the subgraph for this owner, decrypt it,
+ * and return the parsed Digest. Returns null when no digest exists, the
+ * subgraph query fails, or the blob is not decryptable.
+ *
+ * The callback injection keeps this module easy to test — index.ts passes
+ * in the real `searchSubgraph` + `decryptFromHex`, tests can pass fakes.
+ */
+export interface LoadLatestDigestDeps {
+  searchSubgraph: (
+    owner: string,
+    trapdoors: string[],
+    maxCandidates: number,
+    authKeyHex: string,
+  ) => Promise<Array<{ id: string; encryptedBlob: string; createdAt?: string; timestamp?: string }>>;
+  decryptFromHex: (hex: string, key: Buffer) => string;
+}
+
+export async function loadLatestDigest(
+  owner: string,
+  authKeyHex: string,
+  encryptionKey: Buffer,
+  deps: LoadLatestDigestDeps,
+  logger: DigestLogger,
+): Promise<LoadedDigest | null> {
+  let results: Awaited<ReturnType<typeof deps.searchSubgraph>>;
+  try {
+    results = await deps.searchSubgraph(owner, [DIGEST_TRAPDOOR], 10, authKeyHex);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`Digest: subgraph query failed: ${msg}`);
+    return null;
+  }
+  if (!results || results.length === 0) return null;
+
+  // Pick the highest createdAt (client-generated Unix seconds). Fall back to
+  // timestamp (block time) when createdAt is missing.
+  let best: { id: string; encryptedBlob: string; createdAt: number } | null = null;
+  for (const r of results) {
+    const createdAt = parseInt(r.createdAt ?? r.timestamp ?? '0', 10) || 0;
+    if (!best || createdAt > best.createdAt) {
+      best = { id: r.id, encryptedBlob: r.encryptedBlob, createdAt };
+    }
+  }
+  if (!best) return null;
+
+  try {
+    const decrypted = deps.decryptFromHex(best.encryptedBlob, encryptionKey);
+    const canonical = getWasm().parseClaimOrLegacy(decrypted);
+    const digest = extractDigestFromClaim(canonical);
+    if (!digest) {
+      logger.warn(`Digest: blob ${best.id.slice(0, 10)}… did not parse as a digest claim`);
+      return null;
+    }
+    return { digest, claimId: best.id, createdAt: best.createdAt };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`Digest: decrypt failed for ${best.id.slice(0, 10)}…: ${msg}`);
+    return null;
+  }
+}
+
+/**
+ * Probe the subgraph for recency + new-claim signals in one query.
+ *
+ * Fetches the 10 most-recent active facts (sorted by timestamp DESC from the
+ * broadened query), reads each row's `createdAt` (client-generated Unix
+ * seconds), and returns:
+ *
+ *   - `maxCreatedAt`: the largest createdAt across the 10 rows (or 0 if none)
+ *   - `countNewerThan(digestVersion)`: how many of the 10 have createdAt
+ *     strictly greater than the digest's version; clamped at 10 by design
+ *     (one query, one answer)
+ *
+ * That's enough to drive the §15.10 recompile guard: the 10-claim threshold
+ * is exactly what the single query measures. Any user with more than 10 new
+ * claims still trips the guard (we just saturate at 10 instead of knowing
+ * the exact count, which doesn't matter — the guard fires either way).
+ */
+export interface DigestRecencyProbe {
+  maxCreatedAt: number;
+  countNewerThan(digestVersion: number): number;
+}
+
+export interface GetDigestRecencyProbeDeps {
+  searchSubgraphBroadened: (
+    owner: string,
+    maxCandidates: number,
+    authKeyHex: string,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ) => Promise<Array<any>>;
+}
+
+/** How many recent facts we fetch to drive the recompile guard. */
+export const DIGEST_RECENCY_PROBE_LIMIT = 10;
+
+export async function getDigestRecencyProbe(
+  owner: string,
+  authKeyHex: string,
+  deps: GetDigestRecencyProbeDeps,
+): Promise<DigestRecencyProbe> {
+  let results: Array<{ createdAt?: string; timestamp?: string }> = [];
+  try {
+    results = await deps.searchSubgraphBroadened(owner, DIGEST_RECENCY_PROBE_LIMIT, authKeyHex);
+  } catch {
+    return { maxCreatedAt: 0, countNewerThan: () => 0 };
+  }
+  if (!results || results.length === 0) {
+    return { maxCreatedAt: 0, countNewerThan: () => 0 };
+  }
+
+  const createdAts: number[] = [];
+  for (const r of results) {
+    const ts = parseInt(r.createdAt ?? r.timestamp ?? '0', 10);
+    if (!Number.isNaN(ts) && ts > 0) createdAts.push(ts);
+  }
+  const maxCreatedAt = createdAts.length > 0 ? Math.max(...createdAts) : 0;
+
+  return {
+    maxCreatedAt,
+    countNewerThan(digestVersion: number): number {
+      let n = 0;
+      for (const ca of createdAts) if (ca > digestVersion) n++;
+      return n;
+    },
+  };
+}
+
+/**
+ * Fetch all active claims for this owner (up to limit), decrypt each,
+ * parse as canonical Claim, and filter out infrastructure claims
+ * (digest and entity categories) so only user-facing memories remain.
+ *
+ * Returns an array of canonical Claim JSON strings (not parsed objects),
+ * suitable for passing directly to `buildDigestPrompt` / `buildTemplateDigest`
+ * after JSON.stringify-ing the array. The helper wraps them in a JSON array.
+ */
+export interface FetchAllActiveClaimsDeps {
+  searchSubgraphBroadened: (
+    owner: string,
+    maxCandidates: number,
+    authKeyHex: string,
+  ) => Promise<Array<{ id: string; encryptedBlob: string; isActive?: boolean }>>;
+  decryptFromHex: (hex: string, key: Buffer) => string;
+}
+
+export async function fetchAllActiveClaims(
+  owner: string,
+  authKeyHex: string,
+  encryptionKey: Buffer,
+  limit: number,
+  deps: FetchAllActiveClaimsDeps,
+  logger: DigestLogger,
+): Promise<string> {
+  let rows: Awaited<ReturnType<typeof deps.searchSubgraphBroadened>>;
+  try {
+    rows = await deps.searchSubgraphBroadened(owner, limit, authKeyHex);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`Digest: fetchAllActiveClaims subgraph query failed: ${msg}`);
+    return '[]';
+  }
+  if (!rows || rows.length === 0) return '[]';
+
+  const claimsOut: unknown[] = [];
+  for (const row of rows) {
+    if (row.isActive === false) continue;
+    try {
+      const decrypted = deps.decryptFromHex(row.encryptedBlob, encryptionKey);
+      const canonicalJson = getWasm().parseClaimOrLegacy(decrypted);
+      const claim = JSON.parse(canonicalJson) as { c?: string };
+      // Skip infrastructure claims — digest and entity records aren't user memories.
+      if (claim.c === 'dig' || claim.c === 'ent') continue;
+      claimsOut.push(claim);
+    } catch {
+      // Skip un-decryptable / un-parseable rows. Don't fail the whole compilation.
+    }
+  }
+  return JSON.stringify(claimsOut);
+}
+
+// ---------------------------------------------------------------------------
+// Build + inject logic (the full read path pipeline used by the hook)
+// ---------------------------------------------------------------------------
+
+export interface RecompileDigestDeps {
+  /** Called with the canonical Claim JSON string of the new digest. */
+  storeDigestClaim: (canonicalClaimJson: string, compiledAt: string) => Promise<void>;
+  /** Tombstone the previous digest (best-effort; failures are non-fatal). */
+  tombstoneDigest: (claimId: string) => Promise<void>;
+  fetchAllActiveClaimsFn: () => Promise<string>;
+  /** LLM invocation, or null when no LLM is configured. */
+  llmFn: ((prompt: string) => Promise<string>) | null;
+}
+
+export interface RecompileDigestInput {
+  mode: DigestMode;
+  previousClaimId: string | null;
+  nowUnixSeconds: number;
+  deps: RecompileDigestDeps;
+  logger: DigestLogger;
+}
+
+/**
+ * Full recompile pipeline. Safe to fire-and-forget (never throws).
+ *
+ * Steps:
+ *   1. Fetch all active claims (decrypted, filtered to user-facing categories)
+ *   2. Compile via template or LLM (with template fallback)
+ *   3. Wrap as a canonical Claim and encrypt + store on-chain
+ *   4. Tombstone the previous digest (if any) so only one digest stays indexed
+ *
+ * The caller should call `tryBeginRecompile` before scheduling and
+ * `endRecompile` in a finally. This function does not touch the guard itself.
+ */
+export async function recompileDigest(input: RecompileDigestInput): Promise<void> {
+  const { mode, previousClaimId, nowUnixSeconds, deps, logger } = input;
+  try {
+    const claimsJson = await deps.fetchAllActiveClaimsFn();
+    const digestJson = await compileDigestCore({
+      claimsJson,
+      nowUnixSeconds,
+      mode,
+      llmFn: deps.llmFn,
+      logger,
+    });
+    const compiledAt = new Date(nowUnixSeconds * 1000).toISOString();
+    const canonical = buildDigestClaim({ digestJson, compiledAt });
+    await deps.storeDigestClaim(canonical, compiledAt);
+    if (previousClaimId) {
+      try {
+        await deps.tombstoneDigest(previousClaimId);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.warn(`Digest: tombstone of previous ${previousClaimId.slice(0, 10)}… failed: ${msg}`);
+      }
+    }
+    logger.info(`Digest: recompiled and stored (compiledAt=${compiledAt})`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`Digest: recompile failed: ${msg}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Top-level entry: maybeInjectDigest
+// ---------------------------------------------------------------------------
+
+export interface MaybeInjectDigestInput {
+  owner: string;
+  authKeyHex: string;
+  encryptionKey: Buffer;
+  mode: DigestMode;
+  nowMs: number;
+  loadDeps: LoadLatestDigestDeps;
+  probeDeps: GetDigestRecencyProbeDeps;
+  /** Fired (fire-and-forget) if the guard + state say so. */
+  recompileFn: (previousClaimId: string | null) => void;
+  logger: DigestLogger;
+}
+
+export interface MaybeInjectDigestResult {
+  /** When non-null, the caller injects this string into `## Your Memory`. */
+  promptText: string | null;
+  /** For debugging / session debrief. */
+  state: 'off' | 'fresh' | 'stale' | 'first-compile' | 'no-llm-yet';
+}
+
+/**
+ * Top-level read path helper. Decides whether to return a promptText from
+ * the latest digest, kicks off a background recompile when appropriate,
+ * and never throws.
+ *
+ * If this returns `{ promptText: null }`, the caller must fall back to the
+ * legacy individual-fact search path — digest injection is a fast path, not
+ * a replacement.
+ */
+export async function maybeInjectDigest(
+  input: MaybeInjectDigestInput,
+): Promise<MaybeInjectDigestResult> {
+  const {
+    owner,
+    authKeyHex,
+    encryptionKey,
+    mode,
+    nowMs,
+    loadDeps,
+    probeDeps,
+    recompileFn,
+    logger,
+  } = input;
+
+  if (mode === 'off') {
+    return { promptText: null, state: 'off' };
+  }
+
+  // Fetch the latest digest and the recency probe in parallel.
+  const [loaded, probe] = await Promise.all([
+    loadLatestDigest(owner, authKeyHex, encryptionKey, loadDeps, logger),
+    getDigestRecencyProbe(owner, authKeyHex, probeDeps),
+  ]);
+
+  if (!loaded) {
+    // No digest exists yet — schedule a first compile, fall back to legacy search.
+    if (!isRecompileInProgress()) {
+      recompileFn(null);
+    }
+    return { promptText: null, state: 'first-compile' };
+  }
+
+  const digestVersion = typeof loaded.digest.version === 'number'
+    ? loaded.digest.version
+    : parseInt(String(loaded.digest.version ?? 0), 10) || 0;
+  const compiledAt = typeof loaded.digest.compiled_at === 'string' ? loaded.digest.compiled_at : '';
+
+  const state = evaluateDigestState({
+    digestVersion,
+    currentMaxCreatedAt: probe.maxCreatedAt,
+    countNewClaims: probe.countNewerThan(digestVersion),
+    hoursSinceCompilation: hoursSince(compiledAt, nowMs),
+  });
+
+  if (state.stale && state.recompile && !isRecompileInProgress()) {
+    recompileFn(loaded.claimId);
+  }
+
+  const promptText = typeof loaded.digest.prompt_text === 'string' ? loaded.digest.prompt_text : null;
+  return {
+    promptText,
+    state: state.stale ? 'stale' : 'fresh',
+  };
+}

package/embedding.ts

@@ -1,75 +1,98 @@
 /**
  * TotalReclaw Plugin - Local Embedding via @huggingface/transformers
  *
- * Uses the Qwen3-Embedding-0.6B ONNX model to generate 1024-dimensional
- * text embeddings locally. No API key needed, no data leaves the machine.
- * Supports 100+ languages (EN, PT, ES, ZH, etc.).
+ * Generates text embeddings locally using an ONNX model. No API key needed,
+ * no data leaves the machine. Preserves the E2EE guarantee.
  *
- * This preserves the E2EE guarantee: embeddings are generated
- * CLIENT-SIDE before encryption, so no plaintext ever reaches an external API.
+ * Locked to Harrier-OSS-v1-270M (640d, q4, ~344MB, pre-pooled). Changing the
+ * embedding model breaks search across an existing vault, so the
+ * `TOTALRECLAW_EMBEDDING_MODEL` user-facing env var was removed in v1.
  *
- * Model details:
- *   - Quantized (int8) ONNX model: ~600MB download on first use
- *   - Cached in ~/.cache/huggingface/ after first download
- *   - Lazy initialization: first call ~3-5s (model load), subsequent ~100ms
- *   - Output: 1024-dimensional normalized embedding vector
- *   - No instruction prefix needed (bare queries perform better)
- *
- * Dependencies: @huggingface/transformers (handles model download,
- * tokenization, ONNX inference, last-token pooling, and normalization).
+ * Dependencies: @huggingface/transformers
  */
 
 // @ts-ignore - @huggingface/transformers types may not be perfect
-import { pipeline, type FeatureExtractionPipeline } from '@huggingface/transformers';
+import { AutoTokenizer, AutoModel, pipeline, type FeatureExtractionPipeline } from '@huggingface/transformers';
 
-/** ONNX-optimized Qwen3-Embedding-0.6B from HuggingFace Hub. */
-const MODEL_ID = 'onnx-community/Qwen3-Embedding-0.6B-ONNX';
+interface ModelConfig {
+  id: string;
+  dims: number;
+  /** 'sentence_embedding' for models with pre-pooled output, 'mean'/'last_token' for pipeline models */
+  pooling: string;
+  size: string;
+  /** ONNX quantization dtype. Must match an available variant in the HF repo. */
+  dtype: string;
+}
 
-/** Fixed output dimensionality for Qwen3-Embedding-0.6B. */
-const EMBEDDING_DIM = 1024;
+const HARRIER_MODEL: ModelConfig = {
+  id: 'onnx-community/harrier-oss-v1-270m-ONNX',
+  dims: 640,
+  pooling: 'sentence_embedding',
+  size: '~344MB',
+  dtype: 'q4',
+};
 
-/** Lazily initialized feature extraction pipeline. */
-let extractor: FeatureExtractionPipeline | null = null;
+function getModelConfig(): ModelConfig {
+  return HARRIER_MODEL;
+}
+
+/** Lazily initialized model instances. */
+let pipelineExtractor: FeatureExtractionPipeline | null = null;
+let autoTokenizer: any = null;
+let autoModel: any = null;
+let activeModel: ModelConfig | null = null;
 
 /**
- * Generate a 1024-dimensional embedding vector for the given text.
+ * Generate an embedding vector for the given text.
  *
- * On first call, downloads and loads the ONNX model (~600MB, cached).
+ * On first call, downloads and loads the ONNX model (cached after download).
  * Subsequent calls reuse the loaded model and run in ~100ms.
- *
- * The isQuery option is accepted for forward compatibility but does not
- * change behavior -- Qwen3 performs better without instruction prefixes.
- *
- * @param text - The text to embed.
- * @param options - Optional settings.
- * @param options.isQuery - Accepted for forward compatibility (no-op).
- * @returns 1024-dimensional normalized embedding as a number array.
  */
 export async function generateEmbedding(
   text: string,
   options?: { isQuery?: boolean },
 ): Promise<number[]> {
-  if (!extractor) {
-    console.log('Downloading embedding model (one-time setup, ~600MB)...');
-    extractor = await pipeline('feature-extraction', MODEL_ID, {
-      quantized: true,
-    });
-    console.log('Embedding model ready.');
+  if (!activeModel) {
+    activeModel = getModelConfig();
+    console.error(`[TotalReclaw] Downloading embedding model (${activeModel.size}, one-time setup)...`);
+    console.error('[TotalReclaw] This enables semantic search across your encrypted memories.');
+
+    if (activeModel.pooling === 'sentence_embedding') {
+      // Harrier: use AutoModel (pipeline doesn't support sentence_embedding output)
+      autoTokenizer = await AutoTokenizer.from_pretrained(activeModel.id);
+      autoModel = await AutoModel.from_pretrained(activeModel.id, {
+        dtype: activeModel.dtype as any,
+      });
+    } else {
+      // e5-small / Qwen: use pipeline
+      pipelineExtractor = await pipeline('feature-extraction', activeModel.id, {
+        dtype: activeModel.dtype as any,
+      });
+    }
+    console.error('[TotalReclaw] Embedding model ready. Future startups will be instant.');
   }
 
-  const input = text;
-  const output = await extractor(input, { pooling: 'last_token', normalize: true });
-  // output.data is a Float32Array; convert to plain number[]
-  return Array.from(output.data as Float32Array);
+  const model = activeModel!;
+
+  if (model.pooling === 'sentence_embedding') {
+    // Harrier: pre-pooled, pre-normalized output
+    const inputs = await autoTokenizer(text, { return_tensors: 'pt', padding: true });
+    const output = await autoModel(inputs);
+    return Array.from(output.sentence_embedding.data as Float32Array);
+  } else {
+    // Pipeline models: use pooling option
+    const input = model.pooling === 'mean' && options?.isQuery
+      ? `query: ${text}`
+      : text;
+    const output = await pipelineExtractor!(input, { pooling: model.pooling as any, normalize: true });
+    return Array.from(output.data as Float32Array);
+  }
 }
 
 /**
  * Get the embedding vector dimensionality.
- *
- * Always returns 1024 (fixed for Qwen3-Embedding-0.6B).
- * This is needed by downstream code (e.g. LSH hasher) to know the vector
- * size without calling the embedding model.
+ * Returns 640 (default/Harrier), 384 (small), or 1024 (large) depending on model selection.
  */
 export function getEmbeddingDims(): number {
-  return EMBEDDING_DIM;
+  return getModelConfig().dims;
 }