@mindot/will 0.8.0 → 0.10.0

package/src/cognition/faculties/executive.engine/context.ts

@@ -2,6 +2,8 @@
 // src/cognition/faculties/executive.engine/context.ts
 // ─────────────────────────────────────────────────────────────
 
+import { recentActionRecords } from '#faculties/executive.engine/action.record'
+import { AFFECT_STATE_ID } from '#faculties/affective.blender'
 import type { ReadonlySimulationState } from '#core/types'
 import type { GoalManager } from '#faculties/goal.manager'
 import type { WorkingMemory } from '#faculties/working.memory'
@@ -9,6 +11,13 @@ import type { ExecutiveContext } from '#faculties/executive.engine/types'
 import type { EpisodicConsolidator } from '#faculties/episodic.consolidator'
 import type { SemanticIntegrator } from '#faculties/semantic.engine/integrator'
 import { readEffectiveParams, summarizePersonaPrior } from '#cognition/persona.prior'
+import { readIdentityName } from '#cognition/identity.entity'
+import { readSpokenTurns } from '#agency/conversation.aim'
+import { nameOf as referentName } from '#cognition/social.identity'
+
+/** How many of the mind's own recent utterances it is shown. Enough to notice a
+ *  repetition, few enough not to crowd out what is happening now. */
+const SPOKEN_TURNS_SHOWN = 6
 
 export interface ContextDependencies {
   workingMemory: WorkingMemory | null
@@ -32,8 +41,10 @@ export async function buildExecutiveContext(
   // Identity — read directly from the identity-self entity.
   const identityEntity  = state.entities.get('identity-self')
   // name is the canonical persona name from WillConfig.name (e.g. "Aria", "Guard-1").
-  // Falls back to 'Will' for snapshots created before this field was added.
-  const identityName   = (identityEntity?.metadata?.name   as string)                    ?? 'Will'
+  // '' when unknown — NEVER a default. This read used to end in `?? 'Will'`, which
+  // is how the container's name reached a tenant's own prompt. See
+  // cognition/identity.entity for what that cost.
+  const identityName   = readIdentityName( state )
   const identityPrompt = (identityEntity?.metadata?.prompt as string)                    ?? 'I am a self-aware mind.'
   const identityValues = (identityEntity?.metadata?.values as string[])                  ?? []
   const identityTraits = (identityEntity?.metadata?.traits as Record<string, number>)    ?? {}
@@ -44,7 +55,7 @@ export async function buildExecutiveContext(
 
   // Working memory — getItems() returns WMItem[] sorted by activation descending.
   // Filter types that are already rendered elsewhere in the prompt:
-  //   conversation.exchange → shown in Recent Action Outcomes
+  //   conversation.exchange → shown in What Became Of What I Did
   //   goal                  → shown in Active Goals
   const WM_FILTER_TYPES = new Set([ 'conversation.exchange', 'goal' ])
   const wmItems = ( deps.workingMemory?.getItems() ?? [] )
@@ -52,7 +63,12 @@ export async function buildExecutiveContext(
   const workingMemory = wmItems.map( item => ({
     type: item.type,
     summary: extractSummary( item.content ),
-    activation: item.activation
+    activation: item.activation,
+    // Storing the evidence in memory and then rendering only the label would
+    // lose it just as completely, one step later. A percept entity is swept
+    // after 2 ticks and the executive fires on its own schedule, so memory is
+    // often where the mind meets an observation at all.
+    ...( itemData( item.content ) !== undefined ? { data: itemData( item.content ) } : {} ),
   }))
 
   // Episodic memory — semantic query for relevant memories based on current goals
@@ -247,33 +263,46 @@ export async function buildExecutiveContext(
     impulsivity:     execParams.impulsivity     ?? 0.3,
   } : undefined
 
-  // Recent action outcomes — scan decision.record entities that have been processed
-  // (actionStatus is set) and return the last 5 most recent, newest first.
-  // This closes the Act → Confirm → Perceive loop: the executive can see what it
-  // tried, whether it landed, and whether an external dispatch went unanswered.
-  const recentActions: Array<{
-    type: string; status: 'completed' | 'failed' | 'awaiting_host' | 'timed_out'
-    tick: number; outcome: string; planId?: string
-  }> = []
-
-  for( const entity of state.entities.values() ){
-    if( entity.type !== 'decision.record') continue
-    const actionStatus = entity.metadata?.actionStatus as string | undefined
-    if( !actionStatus ) continue
-    if( !( [ 'completed', 'failed', 'awaiting_host', 'timed_out' ] as string[] ).includes( actionStatus ) ) continue
-
-    recentActions.push({
-      type:   ( entity.metadata?.actionType as string )    ?? 'unknown',
-      status: actionStatus as 'completed' | 'failed' | 'awaiting_host' | 'timed_out',
-      tick:   ( entity.metadata?.executionTick as number ) ?? ( entity.metadata?.dispatchedAt as number ) ?? 0,
-      outcome: String( entity.metadata?.outcome ?? '').slice( 0, 120 ),
-      planId: entity.metadata?.planId as string | undefined,
-    })
+  // What became of what I did — this is what closes the Act → Confirm → Perceive
+  // loop the prompt's `## What Became Of What I Did` section was written for.
+  //
+  // It used to scan `decision.record` for an `actionStatus`, a field READ here
+  // and written nowhere in the engine. The section therefore rendered zero times
+  // across every prompt a live COO ever received, while `## What I've Said
+  // Lately` rendered in all of them — the mind could see what it had said and
+  // never what it had done. See `action.record.ts` for what that cost.
+  const recentActionsCapped = recentActionRecords( state.entities as never )
+
+  // Current best name for a person, from the known-entity roster.
+  const nameOf = ( keid: string ): string | undefined => {
+    for( const e of state.entities.values() ){
+      if( e.type !== 'known-entity') continue
+      const m = e.metadata ?? {}
+      if( m['keid'] !== keid ) continue
+      const n = m['name']
+      return typeof n === 'string' && n.trim() ? n : undefined
+    }
+    return undefined
   }
 
-  // Sort newest-first, cap at 5
-  recentActions.sort( ( a, b ) => b.tick - a.tick )
-  const recentActionsCapped = recentActions.slice( 0, 5 )
+  // What the mind has said to people lately, and who answered. Newest first,
+  // capped — this is a reminder, not a transcript; the conversation itself lives
+  // in memory and in "## In Conversation Now".
+  const spokenTurns: ExecutiveContext['spokenTurns'] = readSpokenTurns( state.entities )
+    .filter( t => !t.isAck )
+    .reverse()
+    .slice( 0, SPOKEN_TURNS_SHOWN )
+    .map( t => ({
+      // Roster first, the record's stored name second. A name is learned over
+      // time, so records written before the mind knew it keep the raw id — and
+      // the same person rendered as both `FKEM` and `discord:15255…` in one list,
+      // which reads as two people. The roster holds the current best name.
+      target:   nameOf( t.targetEntityId ) ?? t.targetEntityName ?? t.targetEntityId,
+      preview:  t.preview,
+      age:      Math.max( 0, state.tick - t.tick ),
+      answered: t.answeredAt !== undefined,
+      ...( t.answeredWith ? { answeredWith: t.answeredWith } : {} ),
+    }) )
 
   // Active/known plans — read persisted `plan` entities so the executive has
   // execution awareness: which plans exist per goal, their status + step
@@ -313,7 +342,11 @@ export async function buildExecutiveContext(
       sleepPressure: state.metrics.get('sleep.pressure') ?? 0,
       stressLoad: state.metrics.get('stress.load') ?? 0,
       circadianPhase: state.metrics.get('circadian.phase') ?? 0,
-      timeOfDay: state.metrics.get('time.of_day') ?? 12,
+      // `circadian.time_of_day`, not `time.of_day`. The oscillator has always
+      // written the first and this has always read the second, so the fallback
+      // fired on EVERY tick a Will has ever run: the prompt said `Time: 12.0h`
+      // — noon, permanently — beside a phase label that disagreed with it.
+      timeOfDay: state.metrics.get('circadian.time_of_day') ?? 12,
       // Tonic threat representation — survives event habituation (guardrail).
       threatLevel: state.metrics.get('threat.level') ?? 0
     },
@@ -328,6 +361,7 @@ export async function buildExecutiveContext(
     beliefs,
     beliefsOmitted,
     recentActions: recentActionsCapped,
+    spokenTurns,
     behavioralDisposition,
     selfTuning,
     knownEntities: extractKnownEntities( state ),
@@ -436,6 +470,25 @@ export function extractKnownEntities( state: ReadonlySimulationState ): Executiv
       if( typeof m.name === 'string') a.name = m.name
       if( m.kind === 'thing' || m.kind === 'sentient') a.kind = m.kind as 'thing' | 'sentient'
       if( typeof m.reliability === 'number') a.reliability = m.reliability as number
+
+      // The routes, so choosing where to say something is a decision the mind
+      // makes rather than a fallback the plumbing makes for it.
+      if( Array.isArray( m.handles ) )
+        a.handles = ( m.handles as Array<{ keid?: string; kind?: string; lastAnsweredTick?: number }> )
+          .filter( h => typeof h?.keid === 'string')
+          .map( h => ({
+            keid: h.keid!,
+            kind: h.kind ?? 'unknown',
+            ...( typeof h.lastAnsweredTick === 'number'
+              ? { answeredAgo: Math.max( 0, state.tick - h.lastAnsweredTick ) } : {} ),
+          }) )
+
+      // An identity the mind has not settled. Carried as NAMES where it knows
+      // them, because a raw keid in a prompt is noise it cannot act on.
+      if( Array.isArray( m.suspectedSameAs ) )
+        a.mayBeSameAs = ( m.suspectedSameAs as string[] )
+          .map( k => referentName( state.entities, k ) )
+          .filter( ( n ): n is string => !!n )
       a._recency = Math.max( a._recency, ( m.lastSeenTick as number ) ?? 0 )
     }
     else if( e.type === 'attachment.bond'){
@@ -473,17 +526,11 @@ function buildSemanticQuery(
   const dominantEmotion = valence > 0.3 ? 'positive' : valence < -0.3 ? 'negative' : 'neutral'
   if( dominantEmotion !== 'neutral') parts.push(`Feeling ${dominantEmotion}`)
 
-  // Active conversation entities — pulls memories about current interlocutors
-  const senderNames = new Set<string>()
-  for( const entity of state.entities.values() ){
-    if( entity.type !== 'communication') continue
-    const msgTick = ( entity.metadata?.tick as number ) ?? 0
-    if( state.tick - msgTick > 30 ) continue
-    if( entity.metadata?.processedByExecutive ) continue
-    const name = entity.metadata?.agentName as string | undefined
-    if( name && name !== 'unknown') senderNames.add( name )
-  }
-  if( senderNames.size > 0 ) parts.push(`Talking with: ${[ ...senderNames ].join(', ')}`)
+  // A "Talking with: …" hint used to be built here from `communication` entities.
+  // Nothing has ever written that type (#114), so the clause never fired. Removed
+  // rather than repointed: the inbound entity that now exists (`conversation.received`)
+  // is consumed within one tick, so it is not a dependable source for a recall hint —
+  // restoring this wants a durable interlocutor signal, which is its own decision.
 
   // Recent percepts (top 3 by salience)
   const percepts = extractPercepts( state ).slice( 0, 3 )
@@ -569,6 +616,13 @@ function mapEpisodeToMemory( ep: {
   }
 }
 
+/** A working-memory item's host payload, when it carries one. */
+function itemData( content: unknown ): unknown {
+  if( content && typeof content === 'object')
+    return ( content as Record<string, unknown> )['data']
+  return undefined
+}
+
 function extractSummary( content: unknown ): string {
   if( typeof content === 'string')
     return content.slice( 0, 120 )
@@ -584,8 +638,8 @@ function extractSummary( content: unknown ): string {
   return String( content ?? '').slice( 0, 120 )
 }
 
-function extractPercepts( state: ReadonlySimulationState ): Array<{ category: string; summary: string; salience: number }> {
-  const percepts: Array<{ category: string; summary: string; salience: number }> = []
+function extractPercepts( state: ReadonlySimulationState ): Array<{ category: string; summary: string; salience: number; data?: unknown }> {
+  const percepts: Array<{ category: string; summary: string; salience: number; data?: unknown }> = []
 
   for( const entity of state.entities.values() ){
     if( entity.type !== 'percept' && entity.type !== 'percept.social') continue
@@ -598,6 +652,10 @@ function extractPercepts( state: ReadonlySimulationState ): Array<{ category: st
     percepts.push({
       category: (entity.metadata?.category as string) ?? 'general',
       summary,
+      // What the host actually sent, beside the label the engine wrote. A mind
+      // reasoning only from labels is reasoning from somebody else's summary of
+      // the evidence.
+      ...( entity.metadata?.data !== undefined ? { data: entity.metadata.data } : {} ),
       salience: (entity.metadata?.salience as number) ?? 0
     })
   }
@@ -618,12 +676,14 @@ function extractAffect( state: ReadonlySimulationState ): ExecutiveContext['affe
   const arousal   = state.metrics.get('affect.arousal')   ?? 0.5
   const dominance = state.metrics.get('affect.dominance') ?? 0.5
 
-  // Non-numeric affect data — read from the affective-state entity.
-  // AffectiveBlender writes this entity each tick with dominantEmotion and blends.
+  // Non-numeric affect data — read from the entity AffectiveBlender writes each
+  // tick. The id comes from the writer rather than being spelled again here: this
+  // read used to look for 'affective-state', which nothing has ever written, so
+  // both values silently took their fallbacks in every prompt ever rendered.
   let dominantEmotion = 'neutral'
   let blends: string[] = []
 
-  const affectEntity = state.entities.get('affective-state')
+  const affectEntity = state.entities.get( AFFECT_STATE_ID )
   if( affectEntity ){
     dominantEmotion = (affectEntity.metadata?.dominantEmotion as string) ?? 'neutral'
     blends = (affectEntity.metadata?.blends as string[]) ?? []

package/src/cognition/faculties/executive.engine/deliberate.reasoning.ts

@@ -49,7 +49,7 @@ export async function proposeCandidates( params: ProposeParams ): Promise<Ideati
   try {
     const result = await params.director.call(
       params.systemPrompt, params.ideationUserMessage, params.tick, params.proposeTemperature,
-      params.meta ?? { category: 'executive', attribute: 'master', function: 'ideation' }
+      params.meta ?? { category: 'executive', attribute: 'master', process: 'ideation', function: '-' }
     )
     const candidates = parseIdeation( result.text ).candidates
     return candidates.length > 0 ? candidates : undefined