@mindot/will 0.7.0 → 0.9.0

package/src/cognition/memory/vector.embedder.ts

@@ -12,6 +12,11 @@
  */
 
 import type { TokenTracker } from '#cognition/utilities/token.tracker'
+import type { LLMCallFunction } from '#cognition/utilities/token.tracker'
+import { LLMSemaphore, withGate } from '#llm/gate'
+
+/** Embedding is only ever a read or a write. */
+export type EmbedFunction = Extract<LLMCallFunction, 'recall' | 'index'>
 
 export interface EmbeddingProvider {
   readonly modelName: string
@@ -40,13 +45,27 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
   private _maxConcurrency: number
   private _timeoutMs: number
   private _tokenTracker: TokenTracker | null
+  /**
+   * Own gate — the same LLMSemaphore the LLM calls use, on a separate instance so
+   * embeddings and reasoning do not compete for one another's slots. It bounds the
+   * fan-out that produced the 10.7s tail, and `withGate` additionally retries a 429
+   * with backoff, which a bare `embed()` previously surfaced as a hard failure.
+   */
+  private _gate: LLMSemaphore
 
   constructor( config: {
     modelName: string
     dimensions: number
     apiUrl: string
     apiKey?: string | null
-    /** Max embedding requests in flight at once for embedBatch(). Default 8. */
+    /**
+     * Max embedding requests in flight at once — across ALL callers, not just one
+     * embedBatch(). Default 4, chosen from measured provider behaviour rather than
+     * taste: gemini-embedding-001 answers a lone request in ~1.1s, but queues hard
+     * under fan-out — at 8 in flight the slowest three took 10.7s (all HTTP 200, no
+     * 429, simply serialized). That tail is what made recall exceed its 5s budget
+     * and return "no recall" while a mind with six live facets was asking.
+     */
     maxConcurrency?: number
     /** @deprecated use maxConcurrency — kept as its fallback for back-compat. */
     batchSize?: number
@@ -55,7 +74,7 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     /**
      * Per-Will token tracker. When provided, each embedding call records its
      * input-token usage under the 'embedding' category so memory-vector spend is
-     * visible alongside LLM spend instead of being a silent COGS leak.
+     * visible alongside LLM spend instead of being a silent cost leak.
      */
     tokenTracker?: TokenTracker | null
   } ){
@@ -63,12 +82,24 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     this.dimensions = config.dimensions
     this._apiUrl = config.apiUrl
     this._apiKey = config.apiKey ?? null
-    this._maxConcurrency = Math.max( 1, config.maxConcurrency ?? config.batchSize ?? 8 )
+    this._maxConcurrency = Math.max( 1, config.maxConcurrency ?? config.batchSize ?? 4 )
+    this._gate = new LLMSemaphore( this._maxConcurrency )
     this._timeoutMs = config.timeoutMs ?? 30_000
     this._tokenTracker = config.tokenTracker ?? null
   }
 
-  async embed( content: unknown, fn: string = 'recall'): Promise<number[]> {
+  /**
+   * Embed one item, gated. Every caller funnels through here — a facet building a
+   * prompt, the master recalling, the consolidator indexing — so the gate is the
+   * only place total in-flight fan-out is bounded. Waiting for a slot is strictly
+   * better than the alternative it replaces: an ungated request that returns after
+   * the recall budget has already expired is a request whose answer is thrown away.
+   */
+  async embed( content: unknown, fn: EmbedFunction = 'recall'): Promise<number[]> {
+    return withGate( () => this._embedOnce( content, fn ), `embed:${ this.modelName }`, this._gate )
+  }
+
+  private async _embedOnce( content: unknown, fn: EmbedFunction ): Promise<number[]> {
     let response: Response
     try {
       response = await fetch(`${this._apiUrl}/embeddings`, {
@@ -106,6 +137,21 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     if( !Array.isArray( embedding ) || embedding.length === 0 )
       throw new Error(`Embedding response was empty or malformed for model ${this.modelName}`)
 
+    // The configured width must match what the provider actually returns. This class
+    // sends no `dimensions` param, so the index is sized from config alone — and a
+    // wrong number does not fail, it silently builds an index that can never match.
+    // Providers differ per model family and change defaults between versions, so the
+    // number is checked against reality once rather than trusted. Failing here is safe:
+    // indexing degrades to "deferred" and recall to "no recall", both already
+    // best-effort, and the message carries the value to set.
+    if( embedding.length !== this.dimensions )
+      throw new Error(
+        `Embedding width mismatch for ${ this.modelName }: provider returned ${ embedding.length } ` +
+        `dimensions, index is configured for ${ this.dimensions }. ` +
+        `Set WILL_EMBEDDING_DIMENSIONS=${ embedding.length } (and delete any existing ` +
+        `vector_index built at the old width).`
+      )
+
     // Meter embedding token usage (input-only — embeddings have no completion).
     // Recorded under the 'embedding' category so per-Will dashboards can split
     // memory-vector spend from LLM reasoning spend.
@@ -118,6 +164,7 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
         totalTokens:      usedTok,
         category:         'embedding',
         attribute:        'memory',
+        process:          'cog',        // background: no deliberation happens here
         function:         fn,           // 'recall' (query) | 'index' (write)
         scope:            this.modelName,
         tick:             0,
@@ -128,7 +175,7 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     return embedding
   }
 
-  async embedBatch( contents: unknown[], fn: string = 'index'): Promise<number[][]> {
+  async embedBatch( contents: unknown[], fn: EmbedFunction = 'index'): Promise<number[][]> {
     // Bounded fan-out: cap concurrent requests at _maxConcurrency instead of
     // firing all of them at once (FN16), while preserving input order.
     const results: number[][] = new Array( contents.length )
@@ -170,7 +217,7 @@ export class MockEmbedder implements EmbeddingProvider {
     this._seed = seed
   }
 
-  async embed( content: unknown, _fn: string = 'recall'): Promise<number[]> {
+  async embed( content: unknown, _fn: EmbedFunction = 'recall'): Promise<number[]> {
     const str = typeof content === 'string' ? content : JSON.stringify( content )
     const hash = this._hashString( str )
     const embedding: number[] = []
@@ -184,7 +231,7 @@ export class MockEmbedder implements EmbeddingProvider {
     return embedding
   }
 
-  async embedBatch( contents: unknown[], fn: string = 'index'): Promise<number[][]> {
+  async embedBatch( contents: unknown[], fn: EmbedFunction = 'index'): Promise<number[][]> {
     return Promise.all( contents.map( c => this.embed( c, fn ) ) )
   }
 

package/src/cognition/persona.prior.ts

@@ -118,6 +118,7 @@ const PRIOR_DESCRIPTIONS: Record<string, { lower: string; raise: string }> = {
   'engine-config-inhibition.baseInhibitionStrength':  { lower: 'acting on impulse more freely',              raise: 'holding myself in check more firmly before acting' },
   'engine-config-self-model.minNewExperiences':       { lower: 're-evaluating who I am on less new experience', raise: 'requiring more new experience before re-evaluating who I am' },
   'engine-config-attention.shiftInertia':             { lower: 'shifting my attention more readily',         raise: 'holding my attention more fixedly' },
+  'engine-config-attention.maxFoci':                  { lower: 'attending to one thing at a time, narrowly',  raise: 'keeping several things in view at once' },
   'engine-config-goal-manager.gritPriority':          { lower: 'refusing to give up on more of what matters to me', raise: 'letting go of goals more readily' },
   'engine-config-goal-manager.gritPatienceScale':     { lower: 'losing patience with stuck goals sooner',    raise: 'staying the course on hard goals far longer' },
   'engine-config-goal-manager.frustrationTolerance':  { lower: 'giving up faster when frustrated',            raise: 'holding steady through frustration' },
@@ -129,6 +130,7 @@ const PRIOR_DESCRIPTIONS: Record<string, { lower: string; raise: string }> = {
   'engine-config-executive.riskTolerance':            { lower: 'playing it safer',                            raise: 'taking bigger risks' },
   'engine-config-frustration.irritabilityRate':       { lower: 'letting frustration snowball into a bad mood more slowly', raise: 'getting wound up into a bad mood faster' },
   'engine-config-executive.deliberateThreshold':      { lower: 'stopping to think things through more readily',  raise: 'going with my gut more, deliberating less' },
+  'engine-config-executive.maxFacets':                { lower: 'keeping fewer things going at once, one at a time', raise: 'holding more conversations and threads at once' },
   'engine-config-reward.socialWeight':                { lower: 'caring less about social warmth',               raise: 'finding warmth and connection more rewarding' },
   'engine-config-frustration.angerReactivity':        { lower: 'letting slights go, yielding rather than bristling', raise: 'bristling harder when I feel wronged' },
   'engine-config-novelty.significanceThreshold':      { lower: 'noticing what is new and unusual more readily',  raise: 'needing more for something to strike me as new' },
@@ -143,6 +145,10 @@ const PRIOR_DESCRIPTIONS: Record<string, { lower: string; raise: string }> = {
   'engine-config-action-selector.switchCost':         { lower: 'dropping what I am doing for a new pull more easily', raise: 'seeing an action through, harder to knock off course once underway' },
   'engine-config-action-selector.riskWeight':         { lower: 'weighing the downside of what I do less — acting bolder', raise: 'weighing what could go wrong more heavily before I act' },
   'engine-config-action-selector.noveltyWeight':      { lower: 'feeling less pull toward the untried',               raise: 'drawn more strongly to do the untried and unpracticed' },
+  'engine-config-action-selector.repeatDamping':      { lower: 'following up sooner when I have had no answer',      raise: 'giving people room after I have said my piece' },
+  'engine-config-action-selector.repeatWindowTicks':  { lower: 'coming back to something sooner after I have said it', raise: 'letting what I have said stand for longer before returning to it' },
+  'engine-config-action-selector.replyWindowTicks':   { lower: 'reading a silence as an answer sooner',               raise: 'giving someone longer before I take their quiet as telling me anything' },
+  'engine-config-action-selector.socialWeight':       { lower: 'reaching for people regardless of whether they answer me', raise: 'drawn toward the people who actually answer me' },
   'engine-config-moral.eventThreshold':               { lower: 'holding myself to my principles more sharply',  raise: 'letting moral lapses weigh on me less' },
   'engine-config-frustration.decayRate':              { lower: 'staying frustrated for longer after a setback',  raise: 'shaking off frustration and bouncing back faster' },
   'engine-config-reward.socialWarmthBoost':           { lower: 'being warmed less by a kind exchange',          raise: 'being warmed more by every kind exchange' },