@mindot/will 0.7.0 → 0.9.0

package/src/cognition/faculties/known.entity.tracker.ts

@@ -37,6 +37,9 @@ import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
 import type { Percept } from '#senses/index'
 import { GenerativeModel } from '#cognition/generative.model'
+import {
+  isReferentId, mintReferentId, canonicalOf, withHandle, type Handle,
+} from '#cognition/social.identity'
 import { readEffectiveParams } from '#cognition/persona.prior'
 
 export interface KnownEntityTrackerConfig {
@@ -71,6 +74,31 @@ export interface KnownEntity {
   lastSeenTick:         Tick
   /** 0–1: how identified/coherent this referent is (a name + repeated encounters raise it). */
   resolutionConfidence: number
+  /**
+   * The ways this referent has been reachable, with the circumstances.
+   *
+   * Distinct from an ALIAS, and the distinction is load-bearing: an alias is
+   * another NAME for the same referent (a transport user id), a handle is a
+   * PLACE it can be reached (a thread, a room). One person has one identity and
+   * several rooms, and conflating them is what made "which room should I say
+   * this in?" unaskable.
+   */
+  handles:              Handle[]
+  /**
+   * Referents this one MIGHT be the same someone as, unresolved.
+   *
+   * A blocked merge used to vanish. `_recognise` will only absorb a THIN handle
+   * into an established relationship — rightly, because fusing two real people
+   * who share a name is the dangerous direction — so once the same human was
+   * well-established on two channels they stayed two people permanently, and
+   * nothing anywhere recorded the near-miss.
+   *
+   * A person does not silently fail here. They NOTICE — "hang on, is this the
+   * same Mara?" — and then resolve it by asking. So the doubt is kept, shown, and
+   * left for the mind to settle. Deliberately not a merge: this is a question,
+   * and the answer is the mind's to give.
+   */
+  suspectedSameAs?:     string[]
 }
 
 /** Percept domains whose entities are minds. Everything else defaults to a thing. */
@@ -85,6 +113,19 @@ const CURIOUS_RESOLVED     = 0.6
 // Forgetting (Phase 4). (Reliability rate is now a Channel-A developable field — analytical.)
 const FORGET_FLOOR     = 0.02    // below this familiarity, an unidentified blip is forgotten
 
+/**
+ * Familiarity decay for a referent the mind has NOT resolved — no name, barely
+ * identified. Two orders of magnitude faster than for a known someone, because
+ * one rate cannot serve both: a face glimpsed once in a crowd should fade in
+ * minutes, and a colleague should not.
+ *
+ * The forgetting gate already drew exactly this line (`!d.name &&
+ * resolutionConfidence < CURIOUS_RESOLUTION`); only the rate did not, so slowing
+ * decay enough for relationships to exist would have left every blip resident
+ * forever. Same value the single shared rate used to have.
+ */
+const BLIP_DECAY_RATE  = 0.005
+
 // Recognition (Phase 5) — guards against conflating two *different* people who share a
 // name. Only recognise a still-thin handle (≤) into a known person, and never when both
 // were active at the same time (two people talking at once ⇒ distinct, not one on two
@@ -109,18 +150,50 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
   private _restored = false
 
   // Buffered from senses.*.percept events; drained each tick in react().
-  private _pendingEncounters: Array<{ keid: string; domain: string; name?: string }> = []
+  private _pendingEncounters: Array<{
+    keid: string; domain: string; name?: string
+    /** The room this encounter happened in, and whether it was a private one. */
+    thread?: string; direct?: boolean
+  }> = []
   // Buffered from known.entity.learned (the conscious / reasoning write-path, Phase 2.2).
-  private _pendingConscious: Array<{ keid: string; name?: string; feeling?: number }> = []
+  private _pendingConscious: Array<{
+    keid: string; name?: string; feeling?: number
+    /** "This is the same someone as that." The mind settling an identity itself. */
+    sameAs?: string
+  }> = []
   // Buffered from action.outcome — the reliability track-record signal (Phase 4).
   private _pendingOutcomes: Array<{ keid: string; signal: number }> = []
 
+  /**
+   * Aliases minted this tick, awaiting persistence. `_getOrCreate` runs deep inside
+   * the drain loops with no access to the command list, and an alias that lives
+   * only in memory is one the mind forgets on restart — every transport address
+   * would mint a SECOND anchor next boot and the person would fork in two.
+   */
+  private _mintedAliases: Array<{ alias: string; canonical: string }> = []
+
   private _bus: CognitiveBus | null = null
   private readonly _model = new GenerativeModel()
 
   constructor( config: KnownEntityTrackerConfig = {} ){
     this._growthRate      = config.familiarityGrowthRate ?? 0.15
-    this._decayRate       = config.familiarityDecayRate  ?? 0.005
+    // 0.005/tick spends the entire scale in 200 ticks — under four minutes at the
+    // 1s tick a hosted Will actually runs on. Familiarity could therefore never
+    // accumulate for a mind whose encounters are minutes apart, and it did not:
+    // measured 0.00 on a fresh mind after 5 encounters, and 0.00 on a mind that
+    // had banked 71. A permanently-zero signal is worse than a missing one — it
+    // feeds the curiosity-to-resolve drive (which therefore never fired) and the
+    // pruning order, both of which read it as "a total stranger".
+    //
+    // Mere exposure fades over days, not minutes. At 0.00002 a full scale takes
+    // ~50k ticks (~14h at 1s), so someone met this morning is still familiar
+    // tonight and a stranger from last month has genuinely faded.
+    //
+    // The deeper flaw stays: this is per-TICK, so a psychological timescale is
+    // pinned to a host's tick rate. `react()` already receives the real delta —
+    // expressing decay in experienced time is the actual fix, and it belongs with
+    // the other per-tick decays rather than in this one engine alone.
+    this._decayRate       = config.familiarityDecayRate  ?? 0.00002
     this._curiosityGain   = config.curiosityGain         ?? 1.0
     this._reliabilityRate = config.reliabilityRate       ?? 0.2
     this._maxTracked      = config.maxTracked            ?? 50
@@ -150,9 +223,9 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
 
     // Conscious learning (the reasoning write-path): a learned name + felt valence.
     if( e.type === 'known.entity.learned'){
-      const u = e.payload as { keid?: string; name?: string; feeling?: number }
+      const u = e.payload as { keid?: string; name?: string; feeling?: number; sameAs?: string }
       if( u?.keid && u.keid !== 'agent-self')
-        this._pendingConscious.push({ keid: u.keid, name: u.name, feeling: u.feeling })
+        this._pendingConscious.push({ keid: u.keid, name: u.name, feeling: u.feeling, sameAs: u.sameAs })
       return
     }
 
@@ -170,10 +243,16 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     if( !keid || keid === 'agent-self') return
 
     // A channel-supplied display name rides on the raw input (e.g. TextMessage.speakerName).
-    const raw  = p?.raw as { speakerName?: unknown } | undefined
+    // A channel supplies the display name AND the room, both on the raw input.
+    // `direct` is the one bit the Discord edge computed (`isDM`) and threw away
+    // before the mind could see it — the single fact that decides whether a room
+    // is the right place for a given utterance.
+    const raw  = p?.raw as { speakerName?: unknown; threadId?: unknown; direct?: unknown } | undefined
     const name = typeof raw?.speakerName === 'string' ? raw.speakerName : undefined
+    const thread = typeof raw?.threadId === 'string' ? raw.threadId : undefined
+    const direct = typeof raw?.direct === 'boolean' ? raw.direct : undefined
 
-    this._pendingEncounters.push({ keid, domain: p!.domain, name })
+    this._pendingEncounters.push({ keid, domain: p!.domain, name, thread, direct })
   }
 
   snapshot(): Record<string, unknown> {
@@ -200,8 +279,10 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
 
     // Familiarity fades a little each tick — absence dims the sense of an entity.
     for( const d of this._dossiers.values() )
-      if( d.familiarity > 0 )
-        d.familiarity = Math.max( 0, d.familiarity - this._decayRate )
+      if( d.familiarity > 0 ){
+        const unresolved = !d.name && d.resolutionConfidence < CURIOUS_RESOLUTION
+        d.familiarity = Math.max( 0, d.familiarity - ( unresolved ? BLIP_DECAY_RATE : this._decayRate ) )
+      }
 
     // Drain encounters — each percept is an exposure that re-warms familiarity.
     let touched = false
@@ -210,6 +291,37 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
       d.encounterCount += 1
       d.familiarity     = Math.min( 1, d.familiarity + this._growthRate * ( 1 - d.familiarity ) )
       d.lastSeenTick    = tick
+      // Where this happened is part of what happened. Merged, not appended:
+      // meeting someone again in a room already known is news about that room,
+      // not a new way to reach them.
+      if( enc.thread ){
+        d.handles = withHandle( d.handles, {
+          keid: enc.thread,
+          kind: enc.direct === true ? 'dm' : enc.direct === false ? 'room' : 'unknown',
+          lastSeenTick: tick,
+        } as Handle )
+
+        // The ROOM is a referent too, and gets a dossier of its own.
+        //
+        // `kind: 'thing'` has existed since this tracker shipped and nothing had
+        // ever created one — SENTIENT_DOMAINS admits only audition, so the seat
+        // for a non-person was built and left empty. A place earns exactly the
+        // same things a person does: familiarity with the room, a felt valence
+        // toward it, and a reliability that means something real — whether the
+        // mind gets answered there. A shared room nobody replies in is a fact
+        // about the ROOM as much as about the people in it, and until now there
+        // was nowhere to put it.
+        //
+        // Private threads are deliberately excluded: a DM is not a place, it is
+        // the person. Giving it a dossier would double every someone.
+        if( enc.direct === false ){
+          const place = this._getOrCreate( enc.thread, 'place', tick )
+          place.encounterCount += 1
+          place.familiarity     = Math.min( 1, place.familiarity + this._growthRate * ( 1 - place.familiarity ) )
+          place.lastSeenTick    = tick
+          place.resolutionConfidence = this._resolution( place )
+        }
+      }
       if( enc.name && !d.name ) d.name = enc.name   // learn a name the channel offers
       d.resolutionConfidence = this._resolution( d )
       touched = true
@@ -219,6 +331,16 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     // toward, not slammed). A known someone can exist here with no perceptual encounter.
     for( const u of this._pendingConscious.splice( 0 ) ){
       const d = this._getOrCreate( u.keid, 'audition', tick )   // a known *someone*
+
+      // "These two are the same person." The mind settling a doubt the heuristic
+      // was not entitled to settle — it has reasons a name-match does not, usually
+      // because somebody just told it. Allowed to fuse two ESTABLISHED referents,
+      // which is exactly what `_recognise` refuses to do on its own.
+      if( u.sameAs ){
+        const other = this._dossiers.get( canonicalOf( this._aliases, u.sameAs ) )
+        if( other && other.keid !== d.keid ) this._fuse( d, other, commands )
+      }
+
       if( u.name ) d.name = u.name
       if( u.feeling != null )
         d.valence = Math.max( -1, Math.min( 1, d.valence + 0.5 * ( u.feeling - d.valence ) ) )
@@ -230,7 +352,12 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     // performs when acted on (general: a tool, a place, or a person). Only updates an
     // already-known referent (acting on something you've never perceived doesn't conjure it).
     for( const o of this._pendingOutcomes.splice( 0 ) ){
-      const d = this._dossiers.get( o.keid )
+      // Through the alias table: an `action.outcome` names its target the way the
+      // ACTOR did — a transport address, or whatever the host called it — and the
+      // dossier lives under the anchor. Reading `_dossiers` raw here silently
+      // dropped every outcome once addresses became aliases, so a referent could
+      // never earn or lose reliability again.
+      const d = this._dossiers.get( canonicalOf( this._aliases, o.keid ) )
       if( !d ) continue
       d.reliability = Math.max( 0, Math.min( 1, d.reliability + this._reliabilityRate * ( o.signal - d.reliability ) ) )
       touched = true
@@ -255,6 +382,11 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
         commands.delete!.push(`ke-${d.keid}`)
       }
 
+    // Persist anchors minted this tick BEFORE the dossiers that depend on them.
+    for( const { alias, canonical } of this._mintedAliases.splice( 0 ) )
+      commands.set!.push({ id: `kea-${ alias }`, type: 'known-entity-alias',
+        metadata: { aliasKeid: alias, canonicalKeid: canonical } })
+
     // Persist dossiers (the perceptual layer of the known-entity node).
     for( const d of this._dossiers.values() ){
       if( d.encounterCount === 0 && !d.name ) continue   // keep a named-but-unseen someone
@@ -271,6 +403,8 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
           encounterCount:       d.encounterCount,
           lastSeenTick:         d.lastSeenTick,
           resolutionConfidence: d.resolutionConfidence,
+          handles:              d.handles,
+          ...( d.suspectedSameAs?.length ? { suspectedSameAs: d.suspectedSameAs } : {} ),
         },
       })
     }
@@ -329,10 +463,66 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
   // ── Public API ───────────────────────────────────────────
 
   /** The dossier for a referent, if the Will has one. */
-  getDossier( keid: string ): KnownEntity | undefined { return this._dossiers.get( keid ) }
+  /**
+   * The dossier for anything that names this referent — its anchor, or any address
+   * it has been met at.
+   *
+   * Alias-aware because a caller has no business knowing the anchor. This read
+   * `_dossiers.get(keid)` raw, so the moment addresses became aliases of a minted
+   * anchor, every caller holding a transport id got `undefined` — the mind would
+   * have looked up someone it knows perfectly well and found a stranger. The
+   * existing Phase-4 tests caught it, which is exactly what they are for.
+   */
+  getDossier( keid: string ): KnownEntity | undefined {
+    return this._dossiers.get( canonicalOf( this._aliases, keid ) )
+  }
 
   // ── Internal ─────────────────────────────────────────────
 
+  /**
+   * Absorb `alias` into `canon` — one someone where there were two.
+   *
+   * Shared by the recognition heuristic and by the mind's own `sameAs` verdict,
+   * because "these are the same person" must mean the same thing whichever
+   * concluded it. The only difference is who is ENTITLED to conclude it: the
+   * heuristic will not absorb an established relationship, the mind may, because
+   * it has reasons a name-match does not — usually that somebody just told it.
+   *
+   * Routes MOVE. This used to delete the absorbed dossier and keep only a
+   * redirect, so the mind concluded "same person" and in the same breath threw
+   * away the second way to reach them.
+   */
+  private _fuse( canon: KnownEntity, alias: KnownEntity, commands: StateCommands ): void {
+    canon.encounterCount       += alias.encounterCount
+    canon.familiarity           = Math.max( canon.familiarity, alias.familiarity )
+    canon.resolutionConfidence  = Math.max( canon.resolutionConfidence, alias.resolutionConfidence )
+    canon.lastSeenTick          = Math.max( canon.lastSeenTick as unknown as number, alias.lastSeenTick as unknown as number ) as unknown as Tick
+    canon.valence               = ( canon.valence + alias.valence ) / 2
+    canon.reliability           = ( canon.reliability + alias.reliability ) / 2
+    canon.name                ??= alias.name
+    for( const h of alias.handles ) canon.handles = withHandle( canon.handles, h )
+
+    // The doubt is answered — on both sides, and about each other only. A
+    // suspicion left standing after the fusion would have the mind keep wondering
+    // about a question it has already settled.
+    const settled = ( held: string[] | undefined ): string[] | undefined => {
+      const out = ( held ?? [] ).filter( k => k !== alias.keid && k !== canon.keid )
+      return out.length > 0 ? out : undefined
+    }
+    canon.suspectedSameAs = settled([ ...( canon.suspectedSameAs ?? [] ), ...( alias.suspectedSameAs ?? [] ) ])
+
+    // Every address that pointed at the absorbed referent must now point here, or
+    // the next message from one of them mints the person all over again.
+    for( const [ a, c ] of this._aliases )
+      if( c === alias.keid ) this._aliases.set( a, canon.keid )
+
+    this._dossiers.delete( alias.keid )
+    this._aliases.set( alias.keid, canon.keid )
+    commands.delete!.push(`ke-${ alias.keid }`)
+    commands.set!.push({ id: `kea-${ alias.keid }`, type: 'known-entity-alias',
+      metadata: { aliasKeid: alias.keid, canonicalKeid: canon.keid } })
+  }
+
   /** Resolution confidence: a learned name plus repeated encounters identify a referent. */
   private _resolution( d: KnownEntity ): number {
     return Math.min( 1, ( d.name ? 0.4 : 0 ) + Math.min( 0.6, d.encounterCount * 0.05 ) )
@@ -361,34 +551,61 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
         // handle is already an established relationship, or if both were active concurrently
         // (two interlocutors at once ⇒ distinct). A same-name match alone is too weak.
         const gap = Math.abs( ( canon.lastSeenTick as unknown as number ) - ( alias.lastSeenTick as unknown as number ) )
-        if( alias.encounterCount >= RECOGNITION_MERGE_MAX_ENCOUNTERS || gap < RECOGNITION_CONCURRENCY_WINDOW )
+
+        // Concurrency is evidence AGAINST: two people talking at once are two
+        // people, and there is nothing to wonder about. Say nothing.
+        if( gap < RECOGNITION_CONCURRENCY_WINDOW ) continue
+
+        // Establishment is merely insufficient evidence FOR. The two may well be
+        // one someone; the heuristic is just not entitled to decide it, because
+        // absorbing an established relationship would take a real person's
+        // history with them. So the mind is told, and gets to settle it itself —
+        // usually the way anyone would, by asking.
+        if( alias.encounterCount >= RECOGNITION_MERGE_MAX_ENCOUNTERS ){
+          for( const [ a, b ] of [ [ canon, alias ], [ alias, canon ] ] as const ){
+            const held = a.suspectedSameAs ?? []
+            if( !held.includes( b.keid ) ) a.suspectedSameAs = [ ...held, b.keid ].sort()
+          }
+          merged = true   // the doubt is a change worth persisting
           continue
+        }
 
-        canon.encounterCount       += alias.encounterCount
-        canon.familiarity           = Math.max( canon.familiarity, alias.familiarity )
-        canon.resolutionConfidence  = Math.max( canon.resolutionConfidence, alias.resolutionConfidence )
-        canon.lastSeenTick          = Math.max( canon.lastSeenTick as unknown as number, alias.lastSeenTick as unknown as number ) as unknown as Tick
-        canon.valence               = ( canon.valence + alias.valence ) / 2
-        canon.reliability           = ( canon.reliability + alias.reliability ) / 2
-
-        this._dossiers.delete( alias.keid )
-        this._aliases.set( alias.keid, canon.keid )
-        commands.delete!.push(`ke-${alias.keid}`)
-        commands.set!.push({ id: `kea-${alias.keid}`, type: 'known-entity-alias',
-          metadata: { aliasKeid: alias.keid, canonicalKeid: canon.keid } })
+        this._fuse( canon, alias, commands )
         merged = true
       }
     }
     return merged
   }
 
+  /**
+   * The dossier for a referent, minting its anchor the first time it is met.
+   *
+   * A transport address arriving here (`discord:1019…`) is not an identity, it is
+   * a way the world happened to name someone. So it becomes an ALIAS of a fresh
+   * `ke:` anchor, and the dossier lives under the anchor. Everything downstream —
+   * reputation, theory-of-mind, attachment, goals, the PMA — keeps working
+   * untouched: it still sees one opaque string per referent, which is simply no
+   * longer a route. The same human met later on another channel resolves to this
+   * same anchor instead of becoming a second person nobody could connect.
+   */
   private _getOrCreate( keid: string, domain: string, tick: Tick ): KnownEntity {
-    keid = this._aliases.get( keid ) ?? keid   // a recognised alias lands on the canonical dossier
+    keid = canonicalOf( this._aliases, keid )   // an alias lands on the canonical dossier
     const existing = this._dossiers.get( keid )
     if( existing ) return existing
 
+    // Mint the anchor for a transport address seen for the first time. Deterministic
+    // from that address, so a replay of a recorded run mints the same id (R2).
+    let anchor = keid
+    if( !isReferentId( keid ) ){
+      anchor = mintReferentId( keid )
+      this._aliases.set( keid, anchor )
+      this._mintedAliases.push({ alias: keid, canonical: anchor })
+      const already = this._dossiers.get( anchor )
+      if( already ) return already
+    }
+
     const d: KnownEntity = {
-      keid,
+      keid:                 anchor,
       kind:                 SENTIENT_DOMAINS.has( domain ) ? 'sentient' : 'thing',
       familiarity:          0,
       valence:              0,
@@ -396,15 +613,35 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
       encounterCount:       0,
       lastSeenTick:         tick,
       resolutionConfidence: 0,
+      handles:              [],
     }
-    this._dossiers.set( keid, d )
+    this._dossiers.set( anchor, d )
     return d
   }
 
   /** Keep the most-familiar dossiers; absence-faded acquaintances fall away (forgetting). */
+  /**
+   * Forget the least-held referents when over capacity.
+   *
+   * Ranked by more than exposure, deliberately. This sorted on `familiarity`
+   * alone, which is MERE EXPOSURE — and now that a referent need not be a person
+   * (a document, a repo, a room), things get far more exposure than people do. A
+   * mind that touched sixty files would have evicted a colleague it speaks to
+   * weekly in favour of a config file it opened a lot, silently, taking that
+   * person's reputation, theory-of-mind model and attachment bond with it.
+   *
+   * So a referent the mind has actually got to know is stickier than one it has
+   * merely seen often: knowing their NAME is the single strongest signal (it is
+   * what distinguishes a someone from a blip), then how resolved the referent is,
+   * then exposure. Nothing here is about being a person — a named, well-resolved
+   * document outranks a glimpsed stranger, which is correct.
+   */
   private _prune(): void {
     if( this._dossiers.size <= this._maxTracked ) return
-    const sorted = [ ...this._dossiers.values() ].sort( ( a, b ) => b.familiarity - a.familiarity )
+    const hold = ( d: KnownEntity ): number =>
+      ( d.name ? 1 : 0 ) + d.resolutionConfidence + d.familiarity
+    const sorted = [ ...this._dossiers.values() ]
+      .sort( ( a, b ) => hold( b ) - hold( a ) || ( a.keid < b.keid ? -1 : 1 ) )
     for( const d of sorted.slice( this._maxTracked ) ) this._dossiers.delete( d.keid )
   }
 
@@ -430,6 +667,8 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
         familiarity:          ( m['familiarity']          as number ) ?? 0,
         valence:              ( m['valence']              as number ) ?? 0,
         reliability:          ( m['reliability']          as number ) ?? 0.5,
+        handles:              Array.isArray( m['handles'] ) ? ( m['handles'] as Handle[] ) : [],
+        ...( Array.isArray( m['suspectedSameAs'] ) ? { suspectedSameAs: m['suspectedSameAs'] as string[] } : {} ),
         encounterCount:       ( m['encounterCount']       as number ) ?? 0,
         lastSeenTick:         ( m['lastSeenTick']         as Tick )   ?? ( 0 as unknown as Tick ),
         resolutionConfidence: ( m['resolutionConfidence'] as number ) ?? 0,

package/src/cognition/faculties/moral.evaluator.ts

@@ -308,8 +308,13 @@ export class MoralEvaluator implements SimulationEngine, CognitiveEngine {
           })
       }
 
-      // Own actions that could be violations
-      if( entity.type === 'action.own' || entity.type === 'decision.record'){
+      // Own actions that could be violations. `decision.record` is what carries
+      // them (InhibitionController writes it); an `action.own` alternative was
+      // scanned alongside it and never written by anything (#114). Unlike the
+      // social/threat host seams, this is an INTERNAL record of the mind's own
+      // conduct — not something a host supplies — so the dead half is removed
+      // rather than documented.
+      if( entity.type === 'decision.record'){
         const
         outcome    = entity.metadata?.outcome as string ?? '',
         harmful    = entity.metadata?.harmful === true,
@@ -386,7 +391,7 @@ export class MoralEvaluator implements SimulationEngine, CognitiveEngine {
     let actionCount = 0
 
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'action.own' && entity.type !== 'decision.record') continue
+      if( entity.type !== 'decision.record') continue
 
       const
       virtuous = entity.metadata?.virtuous === true,

package/src/cognition/faculties/persona.consolidator.ts

@@ -135,6 +135,39 @@ const CONSCIENTIOUSNESS_MORAL_GAIN = -0.2   // −moral.eventThreshold per unit
 // native scales — see the selector's effectiveSwitchCost. Lower gain to match the smaller base.
 const CONSCIENTIOUSNESS_SELECTOR_FOCUS_GAIN = 0.1  // +action-selector.switchCost per unit conscientiousness (resists action-interruption)
 
+// Attentional BREADTH — how many focused facets this mind holds at once
+// (engine-config-executive.maxFacets, the FacetSupervisor's ceiling). Two opposing
+// dispositional pulls on one param, the pattern rules 17/17b already use: an open
+// mind spreads itself across more at once, a conscientious one narrows to fewer and
+// sees them through. Scaled against a base of 10, so a strongly-expressed trait moves
+// the ceiling by a few threads, not by an order of magnitude — and consolidatePrior's
+// per-step and cumulative caps bound it regardless.
+const OPENNESS_BREADTH_GAIN          = 4    // +executive.maxFacets per unit openness (hold more at once)
+const CONSCIENTIOUSNESS_BREADTH_GAIN = -3   // −executive.maxFacets per unit conscientiousness (fewer, seen through)
+
+// The same breadth disposition at the ATTENDING level — how many things the mind
+// holds in view at once (engine-config-attention.maxFoci, the allocator's slot cap),
+// as opposed to how many threads it keeps open (maxFacets above). One disposition,
+// two owners — rules 28/28b's pattern. Scaled against a base of 4, so the same trait
+// moves both levels proportionally rather than pulling them apart.
+const OPENNESS_FOCI_GAIN             = 1.5  // +attention.maxFoci per unit openness
+const CONSCIENTIOUSNESS_FOCI_GAIN    = -1.2 // −attention.maxFoci per unit conscientiousness
+
+// How long the Will sits with something it has already said before saying it again
+// (action-selector.repeatDamping, EXAFFERENCE P5). Agreeableness gives people room;
+// demonstrated persistence chases the answer. Scaled against a base of 0.30.
+const AGREEABLENESS_PATIENCE_GAIN    = 0.12  // +repeatDamping per unit agreeableness
+const PERSISTENCE_FOLLOWUP_GAIN      = -0.10 // −repeatDamping per unit persistence
+// The same disposition on the WINDOW rather than the strength: how long what it
+// said stands before coming back to it. Scaled against a base of 60 ticks.
+const AGREEABLENESS_WINDOW_GAIN      = 24   // +repeatWindowTicks per unit agreeableness
+const PERSISTENCE_WINDOW_GAIN        = -20  // −repeatWindowTicks per unit persistence
+// Who the mind is drawn toward. Agreeableness leans into reciprocity (toward the
+// people who answer); demonstrated persistence leans the other way, and can carry
+// this SIGNED weight negative — a mind that reaches hardest for the silence.
+const AGREEABLENESS_RECIPROCITY_GAIN = 0.12  // +action-selector.socialWeight per unit agreeableness
+const PERSISTENCE_RECIPROCITY_GAIN   = -0.14 // −action-selector.socialWeight per unit persistence
+
 // Emotional stability (formed from observed affect dynamics, not task success) develops
 // the affect *reactivity gain* down: a steadier Will lets frustration snowball into
 // chronic irritability more slowly. Distinct axis from resilience — resilience tunes how
@@ -346,6 +379,11 @@ export class PersonaConsolidator implements SimulationEngine, CognitiveEngine {
       [ 'persona.executive.impulsivity_delta',   next.priors[ 'engine-config-executive' ]?.impulsivity ?? 0 ],
       [ 'persona.frustration.irritability_rate_delta', next.priors[ 'engine-config-frustration' ]?.irritabilityRate ?? 0 ],
       [ 'persona.executive.deliberate_threshold_delta', next.priors[ 'engine-config-executive' ]?.deliberateThreshold ?? 0 ],
+      [ 'persona.executive.max_facets_delta',     next.priors[ 'engine-config-executive' ]?.maxFacets ?? 0 ],
+      [ 'persona.attention.max_foci_delta',       next.priors[ 'engine-config-attention' ]?.maxFoci ?? 0 ],
+      [ 'persona.selector.repeat_damping_delta',  next.priors[ 'engine-config-action-selector' ]?.repeatDamping ?? 0 ],
+      [ 'persona.selector.repeat_window_delta',   next.priors[ 'engine-config-action-selector' ]?.repeatWindowTicks ?? 0 ],
+      [ 'persona.selector.social_weight_delta',   next.priors[ 'engine-config-action-selector' ]?.socialWeight ?? 0 ],
       [ 'persona.reward.social_weight_delta', next.priors[ 'engine-config-reward' ]?.socialWeight ?? 0 ],
       [ 'persona.frustration.anger_reactivity_delta', next.priors[ 'engine-config-frustration' ]?.angerReactivity ?? 0 ],
       [ 'persona.novelty.significance_threshold_delta', next.priors[ 'engine-config-novelty' ]?.significanceThreshold ?? 0 ],
@@ -730,6 +768,109 @@ export class PersonaConsolidator implements SimulationEngine, CognitiveEngine {
         engineConfigId: 'engine-config-task-switcher',
         param: 'baseSwitchCost'
       },
+      // 27c. Attentional BREADTH — how many things this mind holds at once (the
+      //      FacetSupervisor's facet ceiling). Openness widens it; conscientiousness
+      //      narrows it. Two opposing pulls on one param (rules 17/17b's pattern), so a
+      //      Will that is both lands somewhere of its own rather than at either extreme.
+      //      This is what makes "I can hold five conversations" or "I do one thing at a
+      //      time" a fact about the person instead of a constant — the ceiling is the
+      //      persona's; spare attention only scales the live allowance within it.
+      {
+        magnitude: openDev,
+        threshold: GRIT_THRESHOLD,
+        gain: OPENNESS_BREADTH_GAIN,
+        engineConfigId: 'engine-config-executive',
+        param: 'maxFacets'
+      },
+      {
+        magnitude: conscDev,
+        threshold: GRIT_THRESHOLD,
+        gain: CONSCIENTIOUSNESS_BREADTH_GAIN,
+        engineConfigId: 'engine-config-executive',
+        param: 'maxFacets'
+      },
+      // 27d. The same breadth disposition one level down: how many things the mind
+      //      holds IN VIEW at once (the allocator's `maxFoci` slots), as against how
+      //      many threads it keeps OPEN (27c). A reasoning facet now competes for
+      //      these slots like any percept, so the two levels are one economy — a Will
+      //      can be in ten conversations while attending to two, and which two is
+      //      settled by salience against everything else it could be noticing.
+      //      `maxFoci` was already config-mirrored and read through the persona-prior;
+      //      it just had no description and no edge, so it could never actually move.
+      {
+        magnitude: openDev,
+        threshold: GRIT_THRESHOLD,
+        gain: OPENNESS_FOCI_GAIN,
+        engineConfigId: 'engine-config-attention',
+        param: 'maxFoci'
+      },
+      {
+        magnitude: conscDev,
+        threshold: GRIT_THRESHOLD,
+        gain: CONSCIENTIOUSNESS_FOCI_GAIN,
+        engineConfigId: 'engine-config-attention',
+        param: 'maxFoci'
+      },
+      // 27e. How long the Will lets its own words stand before repeating them. A
+      //      delivered act leaves a live footprint (EXAFFERENCE P5) that damps redoing
+      //      it; how HARD it damps is a disposition. An agreeable Will gives people
+      //      room after saying its piece; a persistent one chases the answer sooner.
+      //      Opposing pulls on one param, same as 17/17b. This is the trait behind
+      //      "she messaged me the same thing three times" — the mechanism stops the
+      //      loop, this decides where in the range between patient and dogged she sits.
+      {
+        magnitude: agreeableDev,
+        threshold: GRIT_THRESHOLD,
+        gain: AGREEABLENESS_PATIENCE_GAIN,
+        engineConfigId: 'engine-config-action-selector',
+        param: 'repeatDamping'
+      },
+      {
+        magnitude: persistDev,
+        threshold: GRIT_THRESHOLD,
+        gain: PERSISTENCE_FOLLOWUP_GAIN,
+        engineConfigId: 'engine-config-action-selector',
+        param: 'repeatDamping'
+      },
+      // 27f. The same patience on the satiation WINDOW rather than its strength —
+      //      27e decides how hard having spoken damps speaking again, this decides
+      //      for how long. Kept separate because a mind can be quick to repeat but
+      //      only briefly, or slow to repeat but for a long time.
+      {
+        magnitude: agreeableDev,
+        threshold: GRIT_THRESHOLD,
+        gain: AGREEABLENESS_WINDOW_GAIN,
+        engineConfigId: 'engine-config-action-selector',
+        param: 'repeatWindowTicks'
+      },
+      {
+        magnitude: persistDev,
+        threshold: GRIT_THRESHOLD,
+        gain: PERSISTENCE_WINDOW_GAIN,
+        engineConfigId: 'engine-config-action-selector',
+        param: 'repeatWindowTicks'
+      },
+      // 27g. Who the Will is drawn toward. `socialWeight` scales its learned read on
+      //      a person in the action competition, and it is the one weight left
+      //      deliberately SIGNED: agreeableness leans into reciprocity (toward the
+      //      people who answer), demonstrated persistence leans against it and can
+      //      carry the weight negative — a mind that reaches hardest for the silence
+      //      precisely because it is silent. Both are coherent colleagues, so the
+      //      container declines to pick and lets the persona land where it lands.
+      {
+        magnitude: agreeableDev,
+        threshold: GRIT_THRESHOLD,
+        gain: AGREEABLENESS_RECIPROCITY_GAIN,
+        engineConfigId: 'engine-config-action-selector',
+        param: 'socialWeight'
+      },
+      {
+        magnitude: persistDev,
+        threshold: GRIT_THRESHOLD,
+        gain: PERSISTENCE_RECIPROCITY_GAIN,
+        engineConfigId: 'engine-config-action-selector',
+        param: 'socialWeight'
+      },
       // 28b. Same disposition, the AGENCY selector's owner (R2): a conscientious Will also
       //      resists having an in-flight action preempted — raise the selector's switch-cost
       //      hysteresis. Shares the conscientiousness driver with rule 28 (one switch-resistance