@mindot/will 0.1.0

package/src/cognition/faculties/semantic.engine/types.ts

@@ -0,0 +1,53 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/faculties/semantic.engine/types.ts
+// ─────────────────────────────────────────────────────────────
+
+import type { Tick } from '#core/types'
+import type { CognitiveBus } from '#cognition/bus'
+
+// Stop words to strip before text-similarity comparison.
+// Keeps common filler from driving false belief merges.
+export const _STOP_WORDS = new Set([
+  'i','my','me','we','our','you','your','it','its',
+  'the','a','an','and','or','but','in','on','at','to',
+  'for','of','with','by','from','is','are','was','were',
+  'be','been','being','have','has','had','do','does','did',
+  'will','would','could','should','may','might','can',
+  'this','that','these','those','not','no','so','as',
+  'if','then','than','very','just','more','most','also',
+])
+
+export interface SemanticIntegratorConfig {
+  minIntervalTicks?: number
+  minNewEpisodes?: number
+  maxBeliefs?: number
+  /** Ticks without reinforcement before a belief starts losing confidence */
+  beliefStalenessThreshold?: number
+  /** Confidence lost per tick once a belief goes stale */
+  beliefDecayRate?: number
+  /** Minimum similarity threshold for semantic pattern detection (0-1) */
+  semanticSimilarityThreshold?: number
+  /** Maximum episodes to query for semantic pattern detection */
+  semanticQueryLimit?: number
+  bus?: CognitiveBus
+}
+
+export interface BeliefHistoryEntry {
+  tick:       Tick
+  confidence: number  // confidence value after this event
+  delta:      number  // change from previous (positive = gained, negative = lost)
+  cause:      string  // 'created' | 'reinforced' | 'decayed' | 'executive' | 'heuristic' | 'self-model' | 'semantic'
+}
+
+export interface Belief {
+  id: string
+  statement: string
+  category: 'world_fact' | 'self_belief' | 'social_belief' | 'causal_rule' | 'pattern'
+  confidence: number
+  supportingEpisodes: number
+  lastUpdatedAt: Tick
+  tags: string[]
+  /** Bounded trajectory of confidence changes. Max 20 entries; oldest dropped when full.
+   *  Becomes a first-class PMM input — the causal story of how a belief formed. */
+  history?: BeliefHistoryEntry[]
+}

package/src/cognition/faculties/sleep.pressure.regulator.ts

@@ -0,0 +1,262 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/faculties/sleep.pressure.regulator.ts
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * SleepPressureRegulator — accumulates sleep drive during wakefulness
+ * and dissipates it during rest/sleep states.
+ *
+ * Models the two-process sleep model:
+ *   - Process S: homeostatic sleep pressure (accumulates while awake)
+ *   - Process C: circadian modulation (handled by CircadianOscillator)
+ *
+ * High sleep pressure degrades attention, working memory, and
+ * decision quality via modulation signals.
+ *
+ * Part of Shard 0 (Regulatory Layer) — runs every tick, synchronous.
+ */
+
+import type {
+  Duration,
+  Tick,
+  SimulationContext,
+  ReadonlySimulationState,
+  StateCommands,
+  DriveSignal,
+  ModulationSignal,
+  SimulationEvent,
+} from '#core/types'
+import type { SimulationEngine, EngineResult, CognitiveEngine } from '#cognition/types'
+import type { CognitiveEventSchema } from '#cognition/schema.registry'
+import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
+import { GenerativeModel } from '#cognition/generative.model'
+
+export interface SleepPressureConfig {
+  /** Rate at which sleep pressure accumulates while awake (per second of sim time) */
+  wakeAccumulationRate?: number
+  /** Rate at which sleep pressure dissipates during rest (per second of sim time) */
+  restDissipationRate?: number
+  /** Maximum sleep pressure (saturation point) */
+  maxPressure?: number
+  /** Pressure threshold for cognitive degradation onset */
+  fatigueThreshold?: number
+  /** Pressure threshold for severe impairment */
+  exhaustionThreshold?: number
+  bus?: CognitiveBus
+}
+
+export class SleepPressureRegulator implements SimulationEngine, CognitiveEngine {
+  readonly name     = 'sleep-pressure-regulator'
+  
+  private _wakeAccumulationRate: number
+  private _restDissipationRate: number
+  private _maxPressure: number
+  private _fatigueThreshold: number
+  private _exhaustionThreshold: number
+
+  private _wasSleeping: boolean = false
+
+  private _bus: CognitiveBus | null = null
+
+  private readonly _model    = new GenerativeModel()
+
+
+  constructor( config: SleepPressureConfig = {} ){
+    this._bus = config.bus ?? null
+    this._wakeAccumulationRate = config.wakeAccumulationRate ?? 0.008
+    this._restDissipationRate  = config.restDissipationRate  ?? 0.04
+    this._maxPressure          = config.maxPressure          ?? 100
+    this._fatigueThreshold     = config.fatigueThreshold     ?? 40
+    this._exhaustionThreshold  = config.exhaustionThreshold  ?? 70
+  }
+  attachBus( bus: CognitiveBus ): void { this._bus = bus }
+
+  // ── Engine interface ─────────────────────────────────────
+
+
+  subscribes(): string[] { return ['executive.prediction.formed'] }
+  publishes(): CognitiveEventSchema[] {
+    return [
+      { type: 'sleep.begun', version: 1, validate: () => null },
+      { type: 'sleep.ended', version: 1, validate: () => null },
+    ]
+  }
+
+  onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
+    this._model.observe( e.type, e.salience )
+    if( e.type === 'executive.prediction.formed' ){
+      const p = e.payload as { predictedDomains: string[]; confidence: number }
+      if( p.predictedDomains.includes('interoception') )
+        this._model.setPrecision( 'sleep.pressure', 1.0 + p.confidence * 0.5 )
+    }
+  }
+
+  snapshot(): Record<string, unknown> { return {} }
+
+  async react(
+    delta: Duration,
+    _tick: Tick,
+    state: ReadonlySimulationState,
+    context: SimulationContext
+  ): Promise<EngineResult> {
+    this._readConfigFromState( state )
+
+    const
+    currentPressure = state.metrics.get('sleep.pressure') ?? 0,
+    isResting       = state.metrics.get('state.resting') ?? 0,
+    isSleeping      = state.metrics.get('state.sleeping') ?? 0,
+    events:         Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = [],
+    commands:       StateCommands = { metrics: [] }
+
+    const deltaSeconds = delta / 1000
+    let newPressure: number
+
+    if( isSleeping > 0 ){
+      // Deep rest — rapid dissipation
+      newPressure = Math.max( 0, currentPressure - this._restDissipationRate * deltaSeconds * 2 )
+
+      // Fully rested event
+      if( currentPressure > 5 && newPressure <= 5 )
+        events.push({
+          type: 'sleep.fully_rested',
+          source: this.name,
+          payload: { pressure: newPressure },
+        })
+    }
+    else if( isResting > 0 ){
+      // Light rest — moderate dissipation
+      newPressure = Math.max( 0, currentPressure - this._restDissipationRate * deltaSeconds )
+    }
+    else {
+      // Awake — accumulate pressure
+      // Accumulation accelerates as pressure builds (nonlinear fatigue)
+      const pressureRatio  = currentPressure / this._maxPressure,
+            acceleration   = 1 + pressureRatio * 1.5,
+            accumulation   = this._wakeAccumulationRate * acceleration * deltaSeconds
+
+      newPressure = Math.min( this._maxPressure, currentPressure + accumulation )
+
+      // Fatigue onset event
+      if( currentPressure < this._fatigueThreshold && newPressure >= this._fatigueThreshold )
+        events.push({
+          type: 'sleep.fatigue_onset',
+          source: this.name,
+          payload: { pressure: newPressure, threshold: this._fatigueThreshold },
+        })
+
+      // Exhaustion event
+      if( currentPressure < this._exhaustionThreshold && newPressure >= this._exhaustionThreshold )
+        events.push({
+          type: 'sleep.exhaustion',
+          source: this.name,
+          payload: { pressure: newPressure, threshold: this._exhaustionThreshold },
+        })
+    }
+
+    commands.metrics!.push([ 'sleep.pressure', newPressure ])
+
+    // Drive signal
+    const
+    intensity = newPressure / this._maxPressure,
+    urgency   = newPressure >= this._exhaustionThreshold
+                  ? 1.0
+                  : newPressure >= this._fatigueThreshold
+                    ? ( newPressure - this._fatigueThreshold ) / ( this._exhaustionThreshold - this._fatigueThreshold )
+                    : 0
+
+    // Mirror drive intensity as a metric so GoalManager._activateFromDrives() can read it
+    commands.metrics!.push([ 'drive.sleep', intensity ])
+
+    events.push({
+      type: 'drive.sleep',
+      source: this.name,
+      payload: {
+        name: 'sleep',
+        intensity,
+        urgency,
+        source: this.name,
+      } satisfies DriveSignal,
+    })
+
+    // Modulation signals — degrade cognition proportionally to fatigue
+    if( newPressure >= this._fatigueThreshold ){
+      const fatigueRatio = ( newPressure - this._fatigueThreshold )
+                         / ( this._maxPressure - this._fatigueThreshold )
+
+      // Attention degradation
+      events.push({
+        type: 'modulation.attention_degradation',
+        source: this.name,
+        payload: {
+          target: 'attention-allocator',
+          parameter: 'capacity',
+          factor: 1 - fatigueRatio * 0.5,
+          source: this.name,
+        } satisfies ModulationSignal,
+      })
+
+      // Working memory degradation
+      events.push({
+        type: 'modulation.working_memory_degradation',
+        source: this.name,
+        payload: {
+          target: 'working-memory',
+          parameter: 'capacity',
+          factor: 1 - fatigueRatio * 0.6,
+          source: this.name,
+        } satisfies ModulationSignal,
+      })
+
+      // Decision quality degradation (affects LLM temperature or re-evaluation threshold)
+      events.push({
+        type: 'modulation.decision_quality_degradation',
+        source: this.name,
+        payload: {
+          target: 'decision-engine',
+          parameter: 'quality',
+          factor: 1 - fatigueRatio * 0.4,
+          source: this.name,
+        } satisfies ModulationSignal,
+      })
+    }
+
+
+    // Phase C: publish cognitive event
+    const _bus = this._bus
+    if( _bus && newPressure > 70 )
+      _bus.publish({ type: 'sleep.pressure.critical', version: 1, sourceEngine: this.name, salience: Math.max( 0.7, this._model.observe( 'sleep.critical', newPressure ).salience ), payload: { pressure: newPressure } })
+    // Phase D + F: rich state-change event — gated by prediction error
+    if( _bus ){
+      const predErr = this._model.observe( 'sleep.pressure', newPressure )
+      if( !predErr.gated )
+        _bus.publish({ type: 'sleep.state.changed', version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { pressure: newPressure, intensity } })
+    }
+
+    // Sleep transition events — fire once on edge, not every tick
+    const nowSleeping = isSleeping > 0
+    if( _bus ){
+      if( !this._wasSleeping && nowSleeping )
+        _bus.publish({ type: 'sleep.begun', version: 1, sourceEngine: this.name, salience: 0.8, payload: { pressure: newPressure } })
+      else if( this._wasSleeping && !nowSleeping )
+        _bus.publish({ type: 'sleep.ended', version: 1, sourceEngine: this.name, salience: 0.7, payload: { tick: _tick } })
+    }
+    this._wasSleeping = nowSleeping
+
+    return { events: events.length > 0 ? events : undefined, commands }
+  }
+
+  // ── Config hot-reload ────────────────────────────────────
+
+  private _readConfigFromState( state: ReadonlySimulationState ): void {
+    const cfg = state.entities.get('engine-config-sleep')
+    if( !cfg ) return
+
+    const p = cfg.metadata?.params as Record<string, number> | undefined
+    if( !p ) return
+    
+    if( p.wakeAccumulationRate != null ) this._wakeAccumulationRate = p.wakeAccumulationRate
+    if( p.restDissipationRate  != null ) this._restDissipationRate  = p.restDissipationRate
+    if( p.fatigueThreshold     != null ) this._fatigueThreshold     = p.fatigueThreshold
+    if( p.exhaustionThreshold  != null ) this._exhaustionThreshold  = p.exhaustionThreshold
+  }
+}

package/src/cognition/faculties/social.perception.ts

@@ -0,0 +1,333 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/faculties/social.perception.ts
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * SocialPerception — processes social signals from other agents.
+ *
+ * Detects and interprets:
+ *   - Other agents' observable actions
+ *   - Communication directed at this agent
+ *   - Social status and relationship cues
+ *   - Group dynamics and social context
+ *
+ * Produces social percepts with salience that feed into:
+ *   - AttachmentEvaluator (to update relationship models)
+ *   - TheoryOfMind (to update mental models of others)
+ *   - ThreatEvaluator (social evaluation threat)
+ *
+ * Part of Shard 0 (Perceptual Layer) — runs every tick, synchronous.
+ */
+
+import type {
+  Duration,
+  Tick,
+  SimulationContext,
+  ReadonlySimulationState,
+  StateCommands,
+  SimulationEvent,
+} from '#core/types'
+import type { SimulationEngine, EngineResult, CognitiveEngine } from '#cognition/types'
+import type { CognitiveEventSchema } from '#cognition/schema.registry'
+import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
+import { GenerativeModel } from '#cognition/generative.model'
+
+export interface SocialPerceptionConfig {
+  /** Entity types that represent other agents */
+  agentTypes?: string[]
+  /** Entity types that represent social signals */
+  signalTypes?: string[]
+  /** Maximum social percepts per tick */
+  maxPerceptsPerTick?: number
+  bus?: CognitiveBus
+}
+
+interface SocialPercept {
+  keid: string
+  signalType: string
+  action: string
+  valence: number       // -1 (hostile) to +1 (affiliative)
+  intensity: number     // 0-1
+  directedAtSelf: boolean
+  salience: number
+}
+
+export class SocialPerception implements SimulationEngine, CognitiveEngine {
+  readonly name     = 'social-perception'
+  
+  private _agentTypes: Set<string>
+  private _signalTypes: Set<string>
+  private _maxPerceptsPerTick: number
+
+  // Track previously observed actions for change detection
+  private _previousActions = new Map<string, string>()  // keid → last action
+
+  private _bus: CognitiveBus | null = null
+
+  private readonly _model    = new GenerativeModel()
+
+
+  constructor( config: SocialPerceptionConfig = {} ){
+    this._bus = config.bus ?? null
+    this._agentTypes = new Set( config.agentTypes ?? [
+      'agent', 'user', 'contact', 'persona',
+    ])
+    this._signalTypes = new Set( config.signalTypes ?? [
+      'message', 'action', 'expression', 'social_signal', 'communication',
+    ])
+    this._maxPerceptsPerTick = config.maxPerceptsPerTick ?? 20
+  }
+  attachBus( bus: CognitiveBus ): void { this._bus = bus }
+
+  // ── Engine interface ─────────────────────────────────────
+
+  subscribes(): string[] { return ['executive.prediction.formed'] }
+  publishes(): CognitiveEventSchema[] {
+    return [{ type: 'interaction.occurred', version: 1, validate: () => null }]
+  }
+
+  onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
+    this._model.observe( e.type, e.salience )
+    if( e.type === 'executive.prediction.formed' ){
+      const p = e.payload as { predictedDomains: string[]; confidence: number }
+      if( p.predictedDomains.includes('social') )
+        this._model.setPrecision( 'social.agent_count', 1.0 + p.confidence * 0.5 )
+    }
+  }
+
+  snapshot(): Record<string, unknown> { return {} }
+
+  async react(
+    _delta: Duration,
+    tick: Tick,
+    state: ReadonlySimulationState,
+    context: SimulationContext
+  ): Promise<EngineResult> {
+    const
+    events:   Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = [],
+    commands: StateCommands = { set: [], delete: [], metrics: [] }
+
+    const socialPercepts = this._scanSocialSignals( state )
+    const capped = socialPercepts.slice( 0, this._maxPerceptsPerTick )
+
+    // Convert to percept entities
+    for( let i = 0; i < capped.length; i++ ){
+      const sp = capped[i]!
+
+      commands.set!.push({
+        id: `social-percept-${tick}-${i}`,
+        type:     'percept.social',
+        metadata: {
+          tick,
+          keid: sp.keid,
+          signalType: sp.signalType,
+          action: sp.action,
+          valence: sp.valence,
+          intensity: sp.intensity,
+          directedAtSelf: sp.directedAtSelf,
+          salience: sp.salience,
+        },
+      })
+
+      // Update relationship metrics for the perceived agent
+      this._updateRelationshipMetrics( sp, commands.metrics! )
+
+      if( sp.salience > 0.5 )
+        events.push({
+          type: `social.${sp.signalType}`,
+          source: this.name,
+          payload: sp,
+        })
+    }
+
+    // Social presence metrics
+    const activeAgents = this._countActiveAgents( state )
+    commands.metrics!.push(
+      [ 'social.percepts_this_tick', capped.length ],
+      [ 'social.active_agents', activeAgents ],
+      [ 'social.directed_at_self', capped.filter( sp => sp.directedAtSelf ).length ],
+    )
+
+    // Social evaluation threat — how much social scrutiny exists
+    const evaluationThreat = this._computeEvaluationThreat( capped )
+    commands.metrics!.push([ 'social.evaluation_threat', evaluationThreat ])
+
+    // Cleanup
+    commands.delete = this._collectStale( state, tick )
+
+
+    // Phase C + F: publish cognitive event — gated by prediction error
+    const _bus = this._bus
+    if( _bus && activeAgents > 0 ){
+      const predErr = this._model.observe( 'social.agent_count', activeAgents )
+      if( !predErr.gated )
+        _bus.publish({ type: 'social.agents.present', version: 1, sourceEngine: this.name, salience: Math.max( 0.3, predErr.salience ), payload: { activeAgents } })
+    }
+
+    // interaction.occurred — one event per significant percept so subscribers
+    // (theory.of.mind, attachment.evaluator, etc.) get rich per-agent context
+    if( _bus ){
+      for( const sp of capped ){
+        if( !sp.directedAtSelf && Math.abs( sp.valence ) < 0.2 ) continue
+        _bus.publish({
+          type: 'interaction.occurred', version: 1, sourceEngine: this.name,
+          salience: sp.salience,
+          payload: {
+            keid:       sp.keid,
+            valence:       sp.valence,
+            intensity:     sp.intensity,
+            directedAtSelf: sp.directedAtSelf,
+            interactionType: sp.signalType,
+          },
+        })
+      }
+    }
+
+    return { events: events.length > 0 ? events : undefined, commands }
+  }
+
+  // ── Internal ─────────────────────────────────────────────
+
+  private _scanSocialSignals( state: ReadonlySimulationState ): SocialPercept[] {
+    const percepts: SocialPercept[] = []
+    const selfId = 'agent-self'
+
+    for( const [ id, entity ] of state.entities ){
+      // Only process signal-type entities
+      if( !this._signalTypes.has( entity.type ) ) continue
+
+      const
+      sourceKeid = ( entity.metadata?.sourceKeid as string )
+                   ?? ( entity.metadata?.from as string )
+                   ?? 'unknown',
+      action        = ( entity.metadata?.action as string )
+                   ?? ( entity.metadata?.type as string )
+                   ?? entity.type,
+      directedAtSelf = ( entity.metadata?.recipientId as string ) === selfId
+                    || ( entity.metadata?.to as string ) === selfId
+                    || ( entity.metadata?.targetKeid as string ) === selfId
+                    || entity.metadata?.directedAtSelf === true,
+      isNew          = this._previousActions.get( sourceKeid ) !== action
+
+      // Compute valence from entity metadata or defaults
+      const valence = typeof entity.metadata?.valence === 'number'
+                        ? entity.metadata.valence
+                        : this._defaultValence( action )
+
+      // Intensity from explicit metadata or salience
+      const intensity = typeof entity.metadata?.intensity === 'number'
+                          ? entity.metadata.intensity
+                          : typeof entity.metadata?.salience === 'number'
+                            ? entity.metadata.salience
+                            : 0.5
+
+      // Salience: directed at self > new action > repeated action
+      const salience = directedAtSelf ? 0.8 + intensity * 0.2
+                     : isNew           ? 0.4 + intensity * 0.3
+                     : 0.2 + intensity * 0.2
+
+      percepts.push({
+        keid: sourceKeid,
+        signalType: entity.type,
+        action,
+        valence,
+        intensity,
+        directedAtSelf,
+        salience: Math.min( 1, salience ),
+      })
+
+      // Track for change detection
+      this._previousActions.set( sourceKeid, action )
+    }
+
+    // Sort by salience
+    percepts.sort( ( a, b ) => b.salience - a.salience )
+
+    return percepts
+  }
+
+  /**
+   * Default valence mapping for known action types.
+   */
+  private _defaultValence( action: string ): number {
+    const positive = [ 'praise', 'help', 'cooperate', 'greet', 'smile', 'agree', 'support', 'share' ]
+    const negative = [ 'criticize', 'threaten', 'ignore', 'insult', 'attack', 'reject', 'lie', 'betray' ]
+
+    const lower = action.toLowerCase()
+    if( positive.some( p => lower.includes( p ) ) ) return 0.6
+    if( negative.some( n => lower.includes( n ) ) ) return -0.6
+    return 0
+  }
+
+  /**
+   * Update running relationship metrics for a perceived will.
+   */
+  private _updateRelationshipMetrics(
+    percept: SocialPercept,
+    metrics: Array<[string, number]>
+  ): void {
+    const prefix = `relationship.${percept.keid}`
+
+    // Exponential moving average of interaction valence
+    metrics.push([ `${prefix}.valence`, percept.valence ])
+
+    // Count interactions
+    metrics.push([ `${prefix}.interaction_count`, 1 ])
+
+    // Track directed-at-self ratio
+    if( percept.directedAtSelf )
+      metrics.push([ `${prefix}.directed_count`, 1 ])
+  }
+
+  private _countActiveAgents( state: ReadonlySimulationState ): number {
+    let count = 0
+    for( const entity of state.entities.values() ){
+      if( this._agentTypes.has( entity.type ) )
+        count++
+    }
+    return count
+  }
+
+  /**
+   * Compute social evaluation threat — how much social scrutiny is perceived.
+   */
+  private _computeEvaluationThreat( percepts: SocialPercept[] ): number {
+    if( percepts.length === 0 ) return 0
+
+    const
+    directedPercepts = percepts.filter( p => p.directedAtSelf ),
+    negativeDirected = directedPercepts.filter( p => p.valence < 0 )
+
+    if( directedPercepts.length === 0 ) return 0.1
+
+    const
+    negativeRatio = negativeDirected.length / directedPercepts.length,
+    intensityAvg  = directedPercepts.reduce( ( s, p ) => s + p.intensity, 0 ) / directedPercepts.length
+
+    return Math.min( 1, ( negativeRatio * 0.7 + intensityAvg * 0.3 ) * directedPercepts.length / 3 )
+  }
+
+  private _collectStale( state: ReadonlySimulationState, currentTick: Tick ): string[] {
+    const stale: string[] = []
+    for( const [ id, entity ] of state.entities ){
+      // Expire processed percept.social entities after 2 ticks
+      if( entity.type === 'percept.social' && typeof entity.metadata?.tick === 'number'){
+        if( currentTick - entity.metadata.tick > 2 )
+          stale.push( id )
+      }
+      // Expire injected signal entities (communication, message, etc.) after 2 ticks,
+      // BUT only once the executive engine has processed them.
+      // communication entities must survive until the executive fires (5-tick cooldown),
+      // so we must not delete them before processedByExecutive is set — otherwise
+      // messages arriving within 2 ticks of an executive fire are silently lost.
+      if( this._signalTypes.has( entity.type ) && entity.type !== 'percept.social'){
+        if( entity.type === 'communication' && !entity.metadata?.processedByExecutive ) continue
+        const createdAtTick = entity.metadata?.tick as number | undefined
+                           ?? entity.metadata?.injectedAtTick as number | undefined
+        if( typeof createdAtTick === 'number' && currentTick - createdAtTick > 1 )
+          stale.push( id )
+      }
+    }
+    return stale
+  }
+}