@cleocode/core 2026.9.13 → 2026.9.15

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;
@@ -13526,6 +13533,40 @@ var init_invariants = __esm({
   }
 });
 
+// packages/contracts/src/kind-lifecycle.ts
+var KIND_LIFECYCLE_REQUIREMENTS;
+var init_kind_lifecycle = __esm({
+  "packages/contracts/src/kind-lifecycle.ts"() {
+    "use strict";
+    KIND_LIFECYCLE_REQUIREMENTS = Object.freeze({
+      work: {
+        requiresStagedPipeline: true,
+        rationale: "Default delivery work. The staged pipeline exists for exactly this: decide the design before completing the code that implements it."
+      },
+      bug: {
+        requiresStagedPipeline: false,
+        rationale: "A fix operates inside an existing design. Demanding consensus and architecture_decision before a fix can complete describes work that is not happening."
+      },
+      research: {
+        requiresStagedPipeline: false,
+        rationale: "The research IS the work. Requiring the epic to pass the research stage before its own research children can complete is circular."
+      },
+      spike: {
+        requiresStagedPipeline: false,
+        rationale: "A time-boxed exploration whose purpose is to produce the information the design stages would consume. It cannot be gated on having already done so."
+      },
+      experiment: {
+        requiresStagedPipeline: false,
+        rationale: "An experiment is run to learn whether an approach holds. Specifying and decomposing it first presumes the answer."
+      },
+      release: {
+        requiresStagedPipeline: false,
+        rationale: "Release epics are procedural \u2014 the design work they ship was decided in the epics being released."
+      }
+    });
+  }
+});
+
 // packages/contracts/src/lafs.ts
 var init_lafs = __esm({
   "packages/contracts/src/lafs.ts"() {
@@ -16813,6 +16854,7 @@ var init_src = __esm({
     init_branch_lock();
     init_changesets();
     init_cli_category();
+    init_code_symbol();
     init_manifest();
     init_credentials();
     init_daemon();
@@ -16833,6 +16875,7 @@ var init_src = __esm({
     init_goal();
     init_graph();
     init_invariants();
+    init_kind_lifecycle();
     init_lafs();
     init_lease_ipc();
     init_catalog_schema();
@@ -34914,13 +34957,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 +34991,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 +34999,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.
@@ -34983,6 +35073,7 @@ __export(brain_embedding_exports, {
   EMBEDDING_DIMENSIONS: () => EMBEDDING_DIMENSIONS,
   clearEmbeddingProvider: () => clearEmbeddingProvider,
   embedText: () => embedText,
+  ensureEmbeddingProvider: () => ensureEmbeddingProvider,
   getEmbeddingProvider: () => getEmbeddingProvider,
   initDefaultProvider: () => initDefaultProvider,
   isEmbeddingAvailable: () => isEmbeddingAvailable,
@@ -35004,7 +35095,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;
@@ -35014,6 +35109,15 @@ async function initDefaultProvider() {
   const provider = new LocalEmbeddingProvider2();
   setEmbeddingProvider(provider);
 }
+async function ensureEmbeddingProvider() {
+  if (currentProvider !== null) return true;
+  try {
+    await initDefaultProvider();
+  } catch {
+    return false;
+  }
+  return currentProvider !== null;
+}
 var EMBEDDING_DIMENSIONS, currentProvider;
 var init_brain_embedding = __esm({
   "packages/core/src/memory/brain-embedding.ts"() {