@cortexkit/opencode-magic-context 0.49.19 → 0.49.21

package/dist/{index-bjcnntmz.js → index-51rdvtkz.js}

@@ -1,9 +1,9 @@
 import {
   DEFAULT_LOCAL_EMBEDDING_MODEL
-} from "./index-wgypt3cs.js";
+} from "./index-nxrsns5x.js";
 import {
   getSynapseLaneIdentity
-} from "./index-6x57ar45.js";
+} from "./index-wfybj1dw.js";
 import {
   getHarness2
 } from "./index-pavzsdc6.js";
@@ -13,10 +13,10 @@ import {
 import {
   importPluginModule,
   log2
-} from "./index-j75v2476.js";
+} from "./index-h7tgn49j.js";
 import {
   inRootAsyncContext2
-} from "./index-beht37jy.js";
+} from "./index-gzy5w8ya.js";
 import {
   computeNormalizedHash
 } from "./index-2bvekkfy.js";
@@ -100,6 +100,432 @@ function resolveEmbeddingTextPrefixes(model, queryInstruction, documentPrefix) {
   };
 }
 
+// src/features/magic-context/memory/local-embedding-pooling.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+var decisionLogged = new Set;
+var unavailableLogged = new Set;
+var metadataByCache = new Map;
+var testMetadataByModel = new Map;
+var testMetadataFallback;
+var UNRESOLVED_LOCAL_EMBEDDING_POOLING = {
+  status: "unresolved",
+  pooling: "mean",
+  normalize: true,
+  declared: false,
+  reason: "pooling metadata is unavailable; preserving legacy mean pooling and normalization"
+};
+var LEGACY_MEAN_POOLING = {
+  status: "ready",
+  pooling: "mean",
+  normalize: true,
+  declared: false,
+  reason: "no sentence-transformers Pooling module is declared; preserving legacy mean pooling and normalization"
+};
+function defaultModelCacheDir() {
+  return join(getMagicContextStorageDir(), "models");
+}
+function metadataDirectory(model, modelCacheDir) {
+  const digest = createHash("sha256").update(model).digest("hex");
+  return join(modelCacheDir, ".pooling-metadata", digest);
+}
+function parseJson(text, label) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${label} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isModelDirectory(model) {
+  try {
+    return statSync(model).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isPoolingModule(value) {
+  if (!isRecord(value))
+    return false;
+  return typeof value.type === "string" && /(?:^|\.)Pooling$/.test(value.type) || typeof value.name === "string" && value.name.toLowerCase() === "pooling";
+}
+function isNormalizeModule(value) {
+  if (!isRecord(value))
+    return false;
+  return typeof value.type === "string" && /(?:^|\.)Normalize$/.test(value.type) || typeof value.name === "string" && value.name.toLowerCase() === "normalize";
+}
+function safeModulePath(value) {
+  if (typeof value !== "string" || !value.trim())
+    return null;
+  const pieces = value.replaceAll("\\", "/").split("/");
+  if (pieces.some((piece) => piece === ".." || piece === "."))
+    return null;
+  return pieces.filter(Boolean).join("/");
+}
+function poolingFromFiles(modulesText, configText, label) {
+  if (modulesText === null)
+    return LEGACY_MEAN_POOLING;
+  const modulesValue = parseJson(modulesText, `${label}/modules.json`);
+  if (!Array.isArray(modulesValue)) {
+    return {
+      status: "unsupported",
+      normalize: false,
+      declared: true,
+      reason: "modules.json is not a module list"
+    };
+  }
+  const poolingModule = modulesValue.find(isPoolingModule);
+  if (!poolingModule)
+    return LEGACY_MEAN_POOLING;
+  const modulePath = safeModulePath(poolingModule.path);
+  if (modulePath === null || configText === null) {
+    return {
+      status: "unsupported",
+      normalize: modulesValue.some(isNormalizeModule),
+      declared: true,
+      reason: `Pooling module at ${String(poolingModule.path ?? "<missing path>")} has no readable config.json`
+    };
+  }
+  const config = parseJson(configText, `${label}/${modulePath}/config.json`);
+  if (!isRecord(config)) {
+    return {
+      status: "unsupported",
+      normalize: modulesValue.some(isNormalizeModule),
+      declared: true,
+      reason: `Pooling config at ${modulePath}/config.json is not an object`
+    };
+  }
+  const enabledModes = [
+    ["pooling_mode_cls_token", "cls"],
+    ["pooling_mode_mean_tokens", "mean"],
+    ["pooling_mode_lasttoken", "last_token"],
+    ["pooling_mode_max_tokens", undefined],
+    ["pooling_mode_mean_sqrt_len_tokens", undefined],
+    ["pooling_mode_weightedmean_tokens", undefined],
+    ["pooling_mode_mean_last_token", undefined]
+  ].filter(([key]) => config[key] === true);
+  const normalize = modulesValue.some(isNormalizeModule);
+  if (enabledModes.length !== 1) {
+    return {
+      status: "unsupported",
+      normalize,
+      declared: true,
+      reason: enabledModes.length === 0 ? `Pooling config at ${modulePath}/config.json enables no pooling mode` : `Pooling config enables multiple modes: ${enabledModes.map(([key]) => key).join(", ")}`
+    };
+  }
+  const [flag, method] = enabledModes[0];
+  if (!method) {
+    return {
+      status: "unsupported",
+      normalize,
+      declared: true,
+      reason: `unsupported declared pooling mode ${flag}`
+    };
+  }
+  return {
+    status: "ready",
+    pooling: method,
+    normalize,
+    declared: true,
+    reason: `modules.json declares ${flag}; ${normalize ? "a Normalize module is present" : "no Normalize module is declared"}`
+  };
+}
+function poolingMetadataCacheKey(model, modelCacheDir) {
+  return JSON.stringify([model, modelCacheDir]);
+}
+function cachedMetadataPath(model, modelCacheDir) {
+  return join(metadataDirectory(model, modelCacheDir), "resolution.json");
+}
+function parseCachedMetadata(text) {
+  try {
+    const value = JSON.parse(text);
+    if (!isRecord(value) || value.status !== "ready" && value.status !== "unsupported")
+      return null;
+    if (typeof value.normalize !== "boolean" || typeof value.declared !== "boolean" || typeof value.reason !== "string")
+      return null;
+    if (value.status === "ready" && value.pooling !== "mean" && value.pooling !== "cls" && value.pooling !== "last_token")
+      return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function readDirectoryMetadata(model) {
+  const modulesPath = join(model, "modules.json");
+  if (!existsSync(modulesPath))
+    return LEGACY_MEAN_POOLING;
+  const modulesText = readFileSync(modulesPath, "utf8");
+  const moduleList = parseJson(modulesText, `${model}/modules.json`);
+  if (!Array.isArray(moduleList)) {
+    return {
+      status: "unsupported",
+      normalize: false,
+      declared: true,
+      reason: "modules.json is not a module list"
+    };
+  }
+  const poolingModule = moduleList.find(isPoolingModule);
+  const modulePath = poolingModule ? safeModulePath(poolingModule.path) : null;
+  const configText = modulePath ? readFileSync(join(model, modulePath, "config.json"), "utf8") : null;
+  return poolingFromFiles(modulesText, configText, model);
+}
+function getCachedLocalEmbeddingPooling(model, modelCacheDir = defaultModelCacheDir()) {
+  if (testMetadataByModel.has(model))
+    return testMetadataByModel.get(model) ?? null;
+  const cacheKey = poolingMetadataCacheKey(model, modelCacheDir);
+  const cachedInMemory = metadataByCache.get(cacheKey);
+  if (cachedInMemory)
+    return cachedInMemory;
+  if (isModelDirectory(model)) {
+    try {
+      const metadata = readDirectoryMetadata(model);
+      metadataByCache.set(cacheKey, metadata);
+      return metadata;
+    } catch (error) {
+      const metadata = {
+        status: "unsupported",
+        normalize: false,
+        declared: true,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+      metadataByCache.set(cacheKey, metadata);
+      return metadata;
+    }
+  }
+  try {
+    const cached = parseCachedMetadata(readFileSync(cachedMetadataPath(model, modelCacheDir), "utf8"));
+    if (cached) {
+      metadataByCache.set(cacheKey, cached);
+      return cached;
+    }
+  } catch {}
+  if (testMetadataFallback) {
+    metadataByCache.set(cacheKey, testMetadataFallback);
+    return testMetadataFallback;
+  }
+  metadataByCache.set(cacheKey, UNRESOLVED_LOCAL_EMBEDDING_POOLING);
+  return UNRESOLVED_LOCAL_EMBEDDING_POOLING;
+}
+function logLocalEmbeddingPoolingDecisionOnce(model, metadata, logger = log2) {
+  const decisionKey = `${model}:${metadata.status}:${metadata.pooling ?? "none"}:${metadata.normalize}`;
+  if (decisionLogged.has(decisionKey))
+    return;
+  decisionLogged.add(decisionKey);
+  if (metadata.status === "unsupported") {
+    logger(`[magic-context] local embedding pooling for ${model} is unsupported: ${metadata.reason}`);
+  } else {
+    logger(`[magic-context] local embedding pooling for ${model}: ${metadata.pooling} pooling, normalization ${metadata.normalize ? "enabled" : "disabled"} (${metadata.reason})`);
+  }
+}
+function logUnavailableOnce(model, reason, logger) {
+  if (unavailableLogged.has(model))
+    return;
+  unavailableLogged.add(model);
+  logger(`[magic-context] local embedding pooling metadata for ${model} is not available: ${reason}; using legacy mean pooling and retrying during a later background bootstrap`);
+}
+function remoteHost() {
+  const configured = process.env.HF_ENDPOINT?.trim().replace(/\/+$/, "");
+  return configured || "https://huggingface.co";
+}
+function safeRepoId(repo) {
+  return repo.length > 0 && repo.split("/").every((part) => part && part !== "." && part !== "..");
+}
+function modelFileUrl(host, repo, file) {
+  const path = repo.split("/").map(encodeURIComponent).join("/");
+  const filePath = file.split("/").map(encodeURIComponent).join("/");
+  return `${host}/${path}/resolve/main/${filePath}`;
+}
+async function fetchModelFile(host, repo, file, fetcher) {
+  const response = await fetcher(modelFileUrl(host, repo, file));
+  if (response.status === 404)
+    return { kind: "missing" };
+  if (!response.ok)
+    throw new Error(`HTTP ${response.status} fetching ${repo}/${file}`);
+  return { kind: "found", text: await response.text() };
+}
+async function filesForRepo(host, repo, fetcher) {
+  const modules = await fetchModelFile(host, repo, "modules.json", fetcher);
+  if (modules.kind === "missing") {
+    const rootConfigResult = await fetchModelFile(host, repo, "config.json", fetcher);
+    if (rootConfigResult.kind === "missing") {
+      return {
+        modulesText: null,
+        configText: null,
+        configPath: null,
+        rootConfig: null,
+        rootModules: null
+      };
+    }
+    const rootConfigValue = parseJson(rootConfigResult.text, `${repo}/config.json`);
+    const origin = isRecord(rootConfigValue) && typeof rootConfigValue._name_or_path === "string" ? rootConfigValue._name_or_path.trim() : "";
+    if (!origin || origin === repo || !safeRepoId(origin)) {
+      return {
+        modulesText: null,
+        configText: null,
+        configPath: null,
+        rootConfig: rootConfigResult.text,
+        rootModules: null
+      };
+    }
+    const originModules = await fetchModelFile(host, origin, "modules.json", fetcher);
+    if (originModules.kind === "missing") {
+      return {
+        modulesText: null,
+        configText: null,
+        configPath: null,
+        rootConfig: rootConfigResult.text,
+        rootModules: null
+      };
+    }
+    const originModuleList = parseJson(originModules.text, `${origin}/modules.json`);
+    if (!Array.isArray(originModuleList)) {
+      return {
+        modulesText: originModules.text,
+        configText: null,
+        configPath: null,
+        rootConfig: rootConfigResult.text,
+        rootModules: originModules.text
+      };
+    }
+    const poolingModule = originModuleList.find(isPoolingModule);
+    const modulePath = poolingModule ? safeModulePath(poolingModule.path) : null;
+    if (!modulePath) {
+      return {
+        modulesText: originModules.text,
+        configText: null,
+        configPath: null,
+        rootConfig: rootConfigResult.text,
+        rootModules: originModules.text
+      };
+    }
+    const poolingConfig = await fetchModelFile(host, origin, `${modulePath}/config.json`, fetcher);
+    if (poolingConfig.kind === "missing") {
+      return {
+        modulesText: originModules.text,
+        configText: null,
+        configPath: `${origin}/${modulePath}/config.json`,
+        rootConfig: rootConfigResult.text,
+        rootModules: originModules.text
+      };
+    }
+    return {
+      modulesText: originModules.text,
+      configText: poolingConfig.text,
+      configPath: `${origin}/${modulePath}/config.json`,
+      rootConfig: rootConfigResult.text,
+      rootModules: originModules.text
+    };
+  }
+  const modulesValue = parseJson(modules.text, `${repo}/modules.json`);
+  if (!Array.isArray(modulesValue)) {
+    return {
+      modulesText: modules.text,
+      configText: null,
+      configPath: null,
+      rootConfig: null,
+      rootModules: modules.text
+    };
+  }
+  const poolingModule = modulesValue.find(isPoolingModule);
+  const modulePath = poolingModule ? safeModulePath(poolingModule.path) : null;
+  if (!modulePath) {
+    return {
+      modulesText: modules.text,
+      configText: null,
+      configPath: null,
+      rootConfig: null,
+      rootModules: modules.text
+    };
+  }
+  const poolingConfig = await fetchModelFile(host, repo, `${modulePath}/config.json`, fetcher);
+  return {
+    modulesText: modules.text,
+    configText: poolingConfig.kind === "found" ? poolingConfig.text : null,
+    configPath: `${repo}/${modulePath}/config.json`,
+    rootConfig: null,
+    rootModules: modules.text
+  };
+}
+async function cacheRemoteFiles(model, modelCacheDir, files) {
+  const root = metadataDirectory(model, modelCacheDir);
+  const writes = [];
+  if (files.rootConfig !== null)
+    writes.push(writeStorageFileAsync(join(root, "config.json"), files.rootConfig, true));
+  if (files.rootModules !== null)
+    writes.push(writeStorageFileAsync(join(root, "modules.json"), files.rootModules, true));
+  if (files.configText !== null && files.configPath !== null) {
+    const slash = files.configPath.indexOf("/");
+    const repo = files.configPath.slice(0, slash);
+    const relative = files.configPath.slice(slash + 1);
+    writes.push(writeStorageFileAsync(join(root, "source", repo, relative), files.configText, true));
+  }
+  await Promise.all(writes);
+}
+async function preflightLocalEmbeddingPooling(model, options = {}) {
+  const cacheDir = options.modelCacheDir ?? defaultModelCacheDir();
+  const logger = options.logger ?? log2;
+  const cacheKey = poolingMetadataCacheKey(model, cacheDir);
+  const cached = getCachedLocalEmbeddingPooling(model, cacheDir);
+  if (cached && cached.status !== "unresolved") {
+    logLocalEmbeddingPoolingDecisionOnce(model, cached, logger);
+    return cached;
+  }
+  if (isModelDirectory(model)) {
+    try {
+      const metadata = readDirectoryMetadata(model);
+      metadataByCache.set(cacheKey, metadata);
+      testMetadataByModel.delete(model);
+      logLocalEmbeddingPoolingDecisionOnce(model, metadata, logger);
+      return metadata;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const metadata = {
+        status: "unsupported",
+        normalize: false,
+        declared: true,
+        reason
+      };
+      metadataByCache.set(cacheKey, metadata);
+      testMetadataByModel.delete(model);
+      logLocalEmbeddingPoolingDecisionOnce(model, metadata, logger);
+      return metadata;
+    }
+  }
+  try {
+    const fetcher = options.fetcher ?? ((url) => fetch(url, { signal: AbortSignal.timeout(20000) }));
+    const files = await filesForRepo(remoteHost(), model, fetcher);
+    let metadata;
+    try {
+      metadata = poolingFromFiles(files.modulesText, files.configText, model);
+    } catch (error) {
+      metadata = {
+        status: "unsupported",
+        normalize: false,
+        declared: true,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+    await cacheRemoteFiles(model, cacheDir, files);
+    await writeStorageFileAsync(cachedMetadataPath(model, cacheDir), JSON.stringify(metadata), true);
+    metadataByCache.set(cacheKey, metadata);
+    testMetadataByModel.delete(model);
+    logLocalEmbeddingPoolingDecisionOnce(model, metadata, logger);
+    return metadata;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    metadataByCache.set(cacheKey, UNRESOLVED_LOCAL_EMBEDDING_POOLING);
+    testMetadataByModel.delete(model);
+    logUnavailableOnce(model, reason, logger);
+    return UNRESOLVED_LOCAL_EMBEDDING_POOLING;
+  }
+}
+function logLocalEmbeddingPoolingUnavailableOnce(model, reason, logger = log2) {
+  logUnavailableOnce(model, reason, logger);
+}
+
 // src/features/magic-context/memory/embedding-identity.ts
 function normalizeEndpoint(endpoint) {
   return endpoint?.trim().replace(/\/+$/, "") ?? "";
@@ -121,6 +547,8 @@ function getEmbeddingProviderIdentity(config) {
   const truncate = config.provider === "openai-compatible" ? config.truncate?.trim() : undefined;
   const documentPrefix = config.provider === "openai-compatible" ? resolveEmbeddingTextPrefixes(config.model, config.query_instruction, config.document_prefix).documentPrefix : "";
   const localDtype = config.provider === "local" && config.local_dtype && config.local_dtype !== "fp32" ? config.local_dtype : undefined;
+  const localPooling = config.provider === "local" ? getCachedLocalEmbeddingPooling(config.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL) : null;
+  const localPoolingFingerprint = localPooling?.status === "ready" && (localPooling.pooling !== "mean" || !localPooling.normalize) ? `${localPooling.pooling};normalize=${localPooling.normalize}` : undefined;
   const identityInput = config.provider === "openai-compatible" ? {
     provider: "openai-compatible",
     model: config.model.trim(),
@@ -135,15 +563,16 @@ function getEmbeddingProviderIdentity(config) {
     endpoint: "",
     apiKeyPresent: false,
     runtimeFingerprint: LOCAL_EMBEDDING_RUNTIME_FINGERPRINT,
-    ...localDtype ? { localDtype } : {}
+    ...localDtype ? { localDtype } : {},
+    ...localPoolingFingerprint ? { localPooling: localPoolingFingerprint } : {}
   };
   return `embedding-provider:${computeNormalizedHash(JSON.stringify(identityInput))}`;
 }
 
 // src/features/magic-context/memory/embedding-local.ts
-import { readdirSync, statSync } from "node:fs";
+import { readdirSync, statSync as statSync2 } from "node:fs";
 import { stat, unlink } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join as join2 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { workerData } from "node:worker_threads";
 
@@ -298,16 +727,20 @@ class EmbeddingWorkerClient {
   entry;
   timeoutMs;
   prepareTelemetry;
+  idleMs;
   worker = null;
   startPromise = null;
   nextId = 1;
   pending = new Map;
   disposed = false;
-  constructor(data, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./embedding-worker.ts" : "./embedding-worker.js", import.meta.url), timeoutMs = 5 * 60000, prepareTelemetry = prepareNativeOnnxTelemetry) {
+  activeRequests = 0;
+  idleTimer = null;
+  constructor(data, entry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./embedding-worker.ts" : "./embedding-worker.js", import.meta.url), timeoutMs = 5 * 60000, prepareTelemetry = prepareNativeOnnxTelemetry, idleMs = 10 * 60000) {
     this.data = data;
     this.entry = entry;
     this.timeoutMs = timeoutMs;
     this.prepareTelemetry = prepareTelemetry;
+    this.idleMs = idleMs;
   }
   start() {
     if (this.startPromise)
@@ -373,6 +806,7 @@ class EmbeddingWorkerClient {
     const fail = (error) => {
       if (this.worker !== worker)
         return;
+      this.clearIdleTimer();
       this.worker = null;
       for (const request of this.pending.values()) {
         clearTimeout(request.timer);
@@ -397,6 +831,31 @@ class EmbeddingWorkerClient {
   async request(texts, signal) {
     if (signal?.aborted)
       return Promise.reject(new Error("embedding request aborted"));
+    this.activeRequests++;
+    this.clearIdleTimer();
+    try {
+      return await this.requestOnWorker(texts, signal);
+    } finally {
+      this.activeRequests--;
+      this.armIdleTimer();
+    }
+  }
+  clearIdleTimer() {
+    if (this.idleTimer)
+      clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+  }
+  armIdleTimer() {
+    if (this.disposed || this.activeRequests !== 0 || !this.worker)
+      return;
+    this.clearIdleTimer();
+    this.idleTimer = inRootAsyncContext2(() => setTimeout(() => {
+      this.idleTimer = null;
+      this.stop(new Error("embedding worker idle"));
+    }, this.idleMs));
+    this.idleTimer.unref();
+  }
+  async requestOnWorker(texts, signal) {
     const worker = await this.start();
     if (this.disposed)
       throw new Error("embedding worker disposed");
@@ -448,6 +907,7 @@ class EmbeddingWorkerClient {
     });
   }
   async stop(error) {
+    this.clearIdleTimer();
     const worker = this.worker;
     this.worker = null;
     for (const request of this.pending.values()) {
@@ -605,7 +1065,7 @@ var importTransformersNodeWasmFallbackForRuntime = async () => {
   const nodeWasmEntry = new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "../../../../dist/transformers-node-wasm.js" : "./transformers-node-wasm.js", import.meta.url).href;
   return await importPluginModule(() => import(nodeWasmEntry));
 };
-var modelCacheDirForRuntime = () => workerData?.magicContextEmbeddingWorker && typeof workerData.modelCacheDir === "string" ? workerData.modelCacheDir : join(getMagicContextStorageDir(), "models");
+var modelCacheDirForRuntime = () => workerData?.magicContextEmbeddingWorker && typeof workerData.modelCacheDir === "string" ? workerData.modelCacheDir : join2(getMagicContextStorageDir(), "models");
 var logForRuntime = log2;
 var injectWasmOrtForRuntime = injectWasmOrt;
 var loadedLocalEmbeddingRuntimes = new Map;
@@ -614,14 +1074,14 @@ function directoryBytes(path) {
   let total = 0;
   try {
     for (const entry of readdirSync(path, { withFileTypes: true })) {
-      const entryPath = join(path, entry.name);
+      const entryPath = join2(path, entry.name);
       if (entry.isDirectory()) {
         const childBytes = directoryBytes(entryPath);
         if (childBytes === null)
           return null;
         total += childBytes;
       } else if (entry.isFile()) {
-        total += statSync(entryPath).size;
+        total += statSync2(entryPath).size;
       }
     }
     return total;
@@ -847,6 +1307,7 @@ class LocalEmbeddingProvider {
   dtype;
   runtimePreference;
   pipeline = null;
+  poolingMetadata = null;
   workerClient;
   workerLoaded = false;
   initPromise = null;
@@ -924,6 +1385,18 @@ class LocalEmbeddingProvider {
           throw new LocalEmbeddingFsUnavailableError;
         }
         const modelCacheDir = modelCacheDirForRuntime();
+        const cachedPoolingMetadata = getCachedLocalEmbeddingPooling(this.model, modelCacheDir);
+        const poolingMetadata = cachedPoolingMetadata?.status === "unresolved" || !cachedPoolingMetadata ? UNRESOLVED_LOCAL_EMBEDDING_POOLING : cachedPoolingMetadata;
+        if (poolingMetadata.status === "unsupported" || !poolingMetadata.pooling) {
+          throw new Error(`unsupported pooling for local model '${this.model}': ${poolingMetadata.reason}`);
+        }
+        if (poolingMetadata.status === "unresolved") {
+          logLocalEmbeddingPoolingUnavailableOnce(this.model, poolingMetadata.reason, logForRuntime);
+        }
+        this.poolingMetadata = poolingMetadata;
+        if (!workerData?.magicContextEmbeddingWorker) {
+          logLocalEmbeddingPoolingDecisionOnce(this.model, poolingMetadata, logForRuntime);
+        }
         try {
           ensureStorageDirectorySync(modelCacheDir);
           env.cacheDir = modelCacheDir;
@@ -931,7 +1404,7 @@ class LocalEmbeddingProvider {
           log2("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join(modelCacheDir, ".load.lock");
+        const lockPath = join2(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -1038,8 +1511,8 @@ class LocalEmbeddingProvider {
         return null;
       }
       const result = await withQuietConsole(() => pipeline(text, {
-        pooling: "mean",
-        normalize: true
+        pooling: this.poolingMetadata?.pooling ?? "mean",
+        normalize: this.poolingMetadata?.normalize ?? true
       }));
       const embedding = extractBatchEmbeddings(result, 1)[0] ?? null;
       if (!embedding) {
@@ -1090,11 +1563,19 @@ class LocalEmbeddingProvider {
       if (!pipeline) {
         return Array.from({ length: texts.length }, () => null);
       }
-      const result = await withQuietConsole(() => pipeline(texts, {
-        pooling: "mean",
-        normalize: true
-      }));
-      const embeddings = extractBatchEmbeddings(result, texts.length);
+      const pooling = this.poolingMetadata?.pooling ?? "mean";
+      const normalize = this.poolingMetadata?.normalize ?? true;
+      let embeddings;
+      if (pooling === "last_token" && texts.length > 1) {
+        embeddings = [];
+        for (const text of texts) {
+          const result = await withQuietConsole(() => pipeline(text, { pooling, normalize }));
+          embeddings.push(extractBatchEmbeddings(result, 1)[0] ?? null);
+        }
+      } else {
+        const result = await withQuietConsole(() => pipeline(texts, { pooling, normalize }));
+        embeddings = extractBatchEmbeddings(result, texts.length);
+      }
       if (embeddings.every((embedding) => embedding === null)) {
         this.lastFailureReason = classifyLocalEmbeddingFailure(new Error("local embedding pipeline returned no vectors"), { usesWasm: this.usesWasm });
       } else {
@@ -1170,4 +1651,4 @@ class LocalEmbeddingProvider {
   }
 }
 
-export { embeddingModelsMatch, resolveEmbeddingTextPrefixes, getEmbeddingProviderIdentity, dominantEmbeddingFailure, resolveLocalEmbeddingWorkerRuntime, getLocalEmbeddingNativeMemoryStats, LocalEmbeddingProvider };
+export { embeddingModelsMatch, resolveEmbeddingTextPrefixes, getCachedLocalEmbeddingPooling, logLocalEmbeddingPoolingDecisionOnce, preflightLocalEmbeddingPooling, logLocalEmbeddingPoolingUnavailableOnce, getEmbeddingProviderIdentity, dominantEmbeddingFailure, resolveLocalEmbeddingWorkerRuntime, getLocalEmbeddingNativeMemoryStats, LocalEmbeddingProvider };