@cleocode/core 2026.9.13 → 2026.9.14

package/dist/docs/export-document.js

@@ -613,6 +613,13 @@ var init_cli_category = __esm({
   }
 });
 
+// packages/contracts/src/code-symbol.ts
+var init_code_symbol = __esm({
+  "packages/contracts/src/code-symbol.ts"() {
+    "use strict";
+  }
+});
+
 // packages/contracts/src/config/manifest.ts
 import { z as z4 } from "zod";
 var PROJECT_INFO_MANIFEST, PROJECT_CONTEXT_MANIFEST, CLEO_CONFIG_MANIFEST, GLOBAL_CLEO_CONFIG_MANIFEST, CONFIG_MANIFEST_ENTRIES, configManifestEntrySchema;
@@ -16813,6 +16820,7 @@ var init_src = __esm({
     init_branch_lock();
     init_changesets();
     init_cli_category();
+    init_code_symbol();
     init_manifest();
     init_credentials();
     init_daemon();
@@ -34914,13 +34922,33 @@ var init_config = __esm({
 var embedding_local_exports = {};
 __export(embedding_local_exports, {
   LocalEmbeddingProvider: () => LocalEmbeddingProvider,
-  getLocalEmbeddingProvider: () => getLocalEmbeddingProvider
+  __resetLocalEmbeddingStateForTests: () => __resetLocalEmbeddingStateForTests,
+  getLocalEmbeddingProvider: () => getLocalEmbeddingProvider,
+  isEmbeddingPipelineLoaded: () => isEmbeddingPipelineLoaded
 });
 async function loadPipeline() {
   if (_ready) return;
-  const { pipeline } = await import("@huggingface/transformers");
-  _pipeline = await pipeline("feature-extraction", MODEL_NAME);
-  _ready = true;
+  if (_loadFailed) {
+    throw new Error(`Local embedding pipeline is unavailable in this process: ${_loadError}`);
+  }
+  try {
+    const { pipeline } = await import("@huggingface/transformers");
+    _pipeline = await pipeline("feature-extraction", MODEL_NAME);
+    _ready = true;
+  } catch (err) {
+    _loadFailed = true;
+    _loadError = err instanceof Error ? err.message : String(err);
+    throw err;
+  }
+}
+function isEmbeddingPipelineLoaded() {
+  return _ready;
+}
+function __resetLocalEmbeddingStateForTests() {
+  _pipeline = null;
+  _ready = false;
+  _loadFailed = false;
+  _loadError = null;
 }
 function getLocalEmbeddingProvider() {
   if (!_instance) {
@@ -34928,7 +34956,7 @@ function getLocalEmbeddingProvider() {
   }
   return _instance;
 }
-var MODEL_NAME, _pipeline, _ready, LocalEmbeddingProvider, _instance;
+var MODEL_NAME, _pipeline, _ready, _loadFailed, _loadError, LocalEmbeddingProvider, _instance;
 var init_embedding_local = __esm({
   "packages/core/src/memory/embedding-local.ts"() {
     "use strict";
@@ -34936,14 +34964,41 @@ var init_embedding_local = __esm({
     MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
     _pipeline = null;
     _ready = false;
+    _loadFailed = false;
+    _loadError = null;
     LocalEmbeddingProvider = class {
       /** Number of dimensions produced — must match brain_embeddings vec0 table. */
       dimensions = EMBEDDING_DIMENSIONS;
       /**
-       * Whether the pipeline has been successfully initialized and is ready to produce embeddings.
+       * Whether this provider CAN produce embeddings — not whether it already has.
+       *
+       * ## The deadlock this fixes (gh#1217)
+       *
+       * This previously returned `_ready`, the "pipeline has loaded" flag. But
+       * `_ready` is set only by `loadPipeline()`, which runs only inside
+       * {@link embed} — and every caller of `embed` first checks `isAvailable()`.
+       * In any fresh CLI process `_ready` is false, so nothing ever called
+       * `embed`, so `_ready` never became true. **The readiness check could only
+       * be satisfied by the call it guarded.**
+       *
+       * The observable result was total, silent inertness: `cleo brain
+       * maintenance` reported `{processed: 0, skipped: 0, errors: 0}` forever,
+       * `brain_embeddings` stayed empty after dozens of observations, new writes
+       * were never embedded, and every hybrid search quietly degraded to FTS5 —
+       * while `brain.embedding.enabled` was true and the provider itself was
+       * perfectly healthy when called directly.
+       *
+       * Availability is therefore capability: this provider can load its pipeline
+       * on demand, and says so until a load actually fails. The ~22 MB first-call
+       * download is the expected cost of the lazy design, not a reason to refuse
+       * to begin.
+       *
+       * @returns `true` unless loading the pipeline has already failed here.
+       *
+       * @task T12129 (gh#1217)
        */
       isAvailable() {
-        return _ready;
+        return !_loadFailed;
       }
       /**
        * Convert a single text string into a 384-dimension float vector.
@@ -35004,7 +35059,11 @@ function clearEmbeddingProvider() {
 }
 async function embedText(text2) {
   if (!currentProvider?.isAvailable()) return null;
-  return currentProvider.embed(text2);
+  try {
+    return await currentProvider.embed(text2);
+  } catch {
+    return null;
+  }
 }
 function isEmbeddingAvailable() {
   return currentProvider?.isAvailable() ?? false;