claude-brain 0.28.0 → 0.28.1

package/VERSION

@@ -1 +1 @@
-0.28.0
+0.28.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/src/intelligence/inference-router.ts

@@ -64,7 +64,7 @@ const BIO_TYPE_MAP: Record<string, ExtractedEntity['type']> = {
 }
 
 /** Minimum softmax probability to accept a B-/I- entity tag (vs forcing O) */
-const ENTITY_TOKEN_THRESHOLD = 0.5
+const ENTITY_TOKEN_THRESHOLD = 0.25
 
 /** Common words that should never be entities (false positive filter) */
 const ENTITY_STOPWORDS = new Set([
@@ -316,7 +316,7 @@ export class InferenceRouter {
                 normalizedName: name.toLowerCase(),
                 type: entityType,
                 confidence: avgProb,
-                source: 'rule',
+                source: 'model',
                 positions: [startPos],
               })
             }
@@ -519,7 +519,14 @@ export class InferenceRouter {
 
     if (mode === 'both') {
       this.logComparison('knowledge', text, modelResult, regexResult)
-      return modelResult ?? regexResult
+    }
+
+    // Cross-check: if regex found a keyword match (non-'fact') and model disagrees, prefer regex.
+    // Regex only returns non-'fact' when it finds a definitive keyword (prefer, must, goal, etc.)
+    // so it's more trustworthy than an undertrained model for those cases.
+    if (modelResult && regexResult !== 'fact' && modelResult !== regexResult) {
+      this.logger.debug({ modelResult, regexResult }, 'Knowledge cross-check: regex keyword wins over model')
+      return regexResult
     }
 
     if (modelResult) {
@@ -623,20 +630,23 @@ export class InferenceRouter {
       const maxLen = this.modelManager.getManifestEntry('compress')?.maxSeqLen ?? 256
       const { inputIds, attentionMask } = tokenizer.encode(text, maxLen)
 
-      // Greedy autoregressive decode loop
-      const generatedIds: number[] = [...inputIds.filter((_, i) => attentionMask[i] === 1)]
+      // Keep the padded arrays (fixed shape [1, maxLen]) and track active length.
+      // The ONNX model expects fixed input shape [1, maxLen]; stripping padding
+      // would create variable-length tensors that the model rejects.
+      let activeLen = attentionMask.filter(m => m === 1).length
       const maxGenTokens = Math.min(COMPRESS_MAX_TOKENS, maxLen)
+      const inputLen = activeLen
 
       for (let step = 0; step < maxGenTokens; step++) {
-        const currentMask = new Array(generatedIds.length).fill(1)
-        const logits = await this.modelManager.infer('compress', generatedIds, currentMask)
+        if (activeLen >= maxLen) break
+
+        const logits = await this.modelManager.infer('compress', [...inputIds], [...attentionMask])
         if (!logits) break
 
-        // Get logits for the last token position
-        // For seq2seq, the output logits cover the vocabulary
-        const vocabSize = logits.length / generatedIds.length
-        const lastTokenOffset = (generatedIds.length - 1) * vocabSize
-        const lastTokenLogits = logits.slice(lastTokenOffset, lastTokenOffset + vocabSize)
+        // vocabSize = total logits / sequence length (maxLen, the padded dimension)
+        const vocabSize = logits.length / maxLen
+        const lastActiveOffset = (activeLen - 1) * vocabSize
+        const lastTokenLogits = logits.slice(lastActiveOffset, lastActiveOffset + vocabSize)
 
         // Find argmax (greedy decode)
         let bestId = 0
@@ -651,18 +661,21 @@ export class InferenceRouter {
         // Stop on EOS
         if (bestId === EOS_TOKEN_ID || bestId === 0) break
 
-        generatedIds.push(bestId)
+        // Write new token into the next padding slot
+        inputIds[activeLen] = bestId
+        attentionMask[activeLen] = 1
+        activeLen++
       }
 
       // Decode only the generated tokens (after input)
-      const inputLen = inputIds.filter((_, i) => attentionMask[i] === 1).length
-      const outputIds = generatedIds.slice(inputLen)
+      const outputIds = inputIds.slice(inputLen, activeLen)
 
       if (outputIds.length === 0) return null
 
       const decoded = tokenizer.decode(outputIds).trim()
       return decoded.length > 0 ? decoded : null
-    } catch (error) {
+    } catch (err) {
+      const error = err instanceof Error ? { message: err.message, stack: err.stack } : err
       this.logger.warn({ error }, 'Model compression failed, returning original text')
       return null
     }

package/src/intelligence/model-manager.ts

@@ -138,7 +138,8 @@ export class ModelManager {
       this.loadedModels.set(task, loaded)
       this.logger.info({ task, file: entry.file, loadMs: Date.now() - startMs }, 'Model loaded')
       return loaded
-    } catch (error) {
+    } catch (err) {
+      const error = err instanceof Error ? { message: err.message, stack: err.stack } : err
       this.logger.warn({ error, task, file: entry.file }, 'Failed to load model')
       return null
     }
@@ -171,7 +172,8 @@ export class ModelManager {
       const outputKey = Object.keys(results)[0]
       if (!outputKey) return null
       return results[outputKey].data as Float32Array
-    } catch (error) {
+    } catch (err) {
+      const error = err instanceof Error ? { message: err.message, stack: err.stack } : err
       this.logger.warn({ error, task }, 'Inference failed')
       return null
     }

package/src/knowledge/entity-extractor.ts

@@ -10,7 +10,7 @@ export interface ExtractedEntity {
   normalizedName: string
   type: EntityType
   confidence: number
-  source: 'dictionary' | 'nlp' | 'rule'
+  source: 'dictionary' | 'nlp' | 'rule' | 'model'
   positions: number[]
 }