@mindot/will 0.7.0 → 0.9.0

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

@@ -9,6 +9,9 @@ import type { ExecutiveSummarizer } from '#llm/summarizer'
 import type { GoalManager } from '#faculties/goal.manager'
 import type { GenerativeModel } from '#cognition/generative.model'
 import type { SemanticIntegrator } from '#faculties/semantic.engine/integrator'
+import { INNATE_SCHEMA_BY_ID } from '#agency/schemas/innate'
+import { logger } from '#core/logger'
+import { resolveKeid } from '#cognition/social.identity'
 
 /** Maps the LLM's evidence enum to a numeric supportingEpisodes value for the belief store. */
 export const EVIDENCE_TO_COUNT: Record<string, number> = {
@@ -168,10 +171,13 @@ export function buildStateCommands(
           supportingEpisodes: belief.supportingEpisodes, tags: belief.tags } })
       })
 
-      if( bus && ( u.name || u.feeling != null ) )
+      if( bus && ( u.name || u.feeling != null || u.sameAs ) )
         effects.push( () => bus.publish({
           type: 'known.entity.learned', version: 1, sourceEngine: 'executive',
-          salience: 0.5, payload: { keid: u.keid, name: u.name, feeling: u.feeling },
+          // An identity verdict is worth more attention than a learned name: it
+          // reorganises everything the mind holds about two referents at once.
+          salience: u.sameAs ? 0.7 : 0.5,
+          payload: { keid: u.keid, name: u.name, feeling: u.feeling, sameAs: u.sameAs },
         }) )
     })
   }
@@ -321,6 +327,32 @@ export function publishCognitiveEvents(
       }
     })
 
+  // agency.composite.proposed — the mind names a compound action as one skill.
+  //
+  // This is the creation seam for the instrumental→habitual gradient, and it had
+  // no producer: ReafferenceEngine subscribes to this event and its handler is the
+  // ONLY caller of SchemaRepertoire.registerComposite() anywhere in the tree, so
+  // until now no Will could hold a skill beyond the innate floor, for its entire
+  // life (#114). A capability the container offered and no tenant could reach.
+  //
+  // One event per proposal — the consumer registers them individually and drops
+  // anything with fewer than two sub-schemas, since a "composite" of one is just
+  // the schema it already had.
+  for( const skill of output.newSkills ?? [] )
+    bus.publish({
+      type: 'agency.composite.proposed',
+      version: 1,
+      sourceEngine: 'executive-engine',
+      salience: 0.7,
+      payload: {
+        id:         skill.id,
+        composedOf: skill.composedOf,
+        ...( skill.tags ? { tags: skill.tags } : {} ),
+        ...( typeof skill.cost === 'number' ? { cost: skill.cost } : {} ),
+        tick: footprint.tickObserved,
+      }
+    })
+
   // goal.proposed — when executive proposes new goals
   if( output.newGoals?.length )
     bus.publish({
@@ -372,20 +404,45 @@ export function publishCognitiveEvents(
   })
 }
 
-const COMMUNICATE_ACTION_TYPES = new Set([
+/**
+ * Action names that mean "say something to someone". Exported because the
+ * conversation facet partitions its OWN actions by the same rule (an action
+ * aimed at a third party is an intention the master owns, not a reply the facet
+ * may deliver) — one definition, so the two ends cannot drift apart.
+ */
+export const COMMUNICATE_ACTION_TYPES = new Set([
   'communicate', 'speak', 'initiate_conversation', 'reach-out', 'reach_out', 'talk', 'text', 'message',
 ])
 
+/** Arg keys a mind uses for the words themselves — folded into `gist` (see below). */
+const WORDS_ARG_KEYS   = new Set([ 'content', 'message', 'text', 'body' ])
+/** Arg keys naming the addressee — already resolved into `targetEntityId`. */
+const ADDRESS_ARG_KEYS = new Set([ 'to', 'recipient', 'target', 'targetEntityId', 'entityId' ])
+
 /** Resolve an executive action target (a display name OR a keid) to a known-entity keid. */
 function resolveKnownEntity( target: string, state: ReadonlySimulationState ): string | undefined {
-  const t = target.trim().toLowerCase()
+  // THE resolver, shared with everything else that has to turn a reference into a
+  // referent. This was a private scan matching an exact keid or an exact name and
+  // consulting no alias table — so once dossiers were keyed by an anchor, naming
+  // someone by the address they were met at (`discord:1019…`) matched nothing and
+  // the whole intention evaporated silently, which is the failure this function's
+  // own logging exists to make visible.
+  return resolveKeid( state.entities as never, target )
+}
+
+/**
+ * The name the mind has LEARNED for this entity. The outreach facet addresses someone
+ * by it ("I have decided to reach out to ${ name }"), so a keid leaking through here
+ * would have the mind reaching out to `discord:1019376031150379101`. Undefined when
+ * unlearned — the caller omits it rather than substituting a placeholder.
+ */
+function knownEntityName( keid: string, state: ReadonlySimulationState ): string | undefined {
   for( const e of state.entities.values() ){
     if( e.type !== 'known-entity') continue
-    const m    = e.metadata as Record<string, unknown> | undefined
-    const keid = typeof m?.['keid'] === 'string' ? m['keid'] as string : undefined
-    const name = typeof m?.['name'] === 'string' ? m['name'] as string : undefined
-    if( keid && keid.toLowerCase() === t ) return keid
-    if( name && name.toLowerCase() === t ) return keid
+    const m = e.metadata as Record<string, unknown> | undefined
+    if( m?.['keid'] !== keid ) continue
+    const name = typeof m['name'] === 'string' ? m['name'].trim() : ''
+    return name.length > 0 ? name : undefined
   }
   return undefined
 }
@@ -408,6 +465,10 @@ function buildIdeomotorIntents(
 ): { set: EntityInput[]; delete: string[] } {
   const set:  EntityInput[] = []
   const seen = new Set<string>()
+  /** Action names that named nothing this cycle — surfaced back to the mind below. */
+  const unresolved = new Set<string>()
+  /** Addressees the mind meant to reach but cannot resolve to anyone it knows. */
+  const unaddressed = new Set<string>()
   const priority = clamp01( output.confidence ?? 0.8 )
 
   // The host abilities currently afforded (source 'external' in the live field) —
@@ -425,21 +486,83 @@ function buildIdeomotorIntents(
     const t = action.type.toLowerCase()
 
     if( COMMUNICATE_ACTION_TYPES.has( t ) ){
-      if( !action.target ) continue
-      const keid = resolveKnownEntity( action.target, state )
-      if( !keid || seen.has( keid ) ) continue
+      // The addressee may be named on the action OR inside the args the executive
+      // authored. This used to read `action.target` alone and `continue` when it
+      // was absent — but the output guidelines document actions as
+      // `{type, reasoning, expectedOutcome}` and tell the mind to put specifics
+      // in `args`, so `args.to` is precisely what a well-behaved mind produces.
+      // A Will would write real sentences into `args.to`/`args.content`, the
+      // intent was never created, nothing competed, nothing was ever enqueued —
+      // and reafference then taught it that talking to that PERSON does not work.
+      const args = ( action.args && typeof action.args === 'object' ? action.args : {} ) as Record<string, unknown>
+      const named = [ action.target, args['to'], args['recipient'], args['target'], args['targetEntityId'], args['entityId'] ]
+        .find( v => typeof v === 'string' && v.trim().length > 0 ) as string | undefined
+      // Naming NOBODY and naming someone unreachable are different failures, and
+      // both used to `continue` in silence — the intent was never created, nothing
+      // competed, and the mind had no way to find out. Observed: a facet decided to
+      // contact a colleague by a name the mind had heard in conversation but never
+      // bound to a dossier; the whole intention evaporated without a trace, and the
+      // person it had just promised never heard from it.
+      if( !named ){ unaddressed.add('(no one)'); continue }
+      const keid = resolveKnownEntity( named, state )
+      if( !keid ){ unaddressed.add( named ); continue }
+      if( seen.has( keid ) ) continue
       seen.add( keid )
+      // The master forms the INTENT; it does not author the words. Whatever it wrote
+      // is the DIRECTION for the outreach facet (AuditionEngine.authorOutreach) to
+      // speak in — so it lands in `gist`, never `content`. This is load-bearing:
+      // MotorSchemaExecutor._deliver sends `parameters.content` VERBATIM and only
+      // falls back to the facet when it is empty, so carrying the master's sentences
+      // as `content` would put the master itself in a second, parallel conversation
+      // with someone a conversation facet may already be talking to — one mind
+      // holding two threads with one person about one thing. `gist` was read in
+      // three places and written nowhere; this is what writes it.
+      const said = [ ...WORDS_ARG_KEYS ]
+        .map( k => args[ k ] )
+        .find( v => typeof v === 'string' && v.trim().length > 0 ) as string | undefined
+      const parameters: Record<string, unknown> = {}
+      for( const [ k, v ] of Object.entries( args ) )
+        if( !WORDS_ARG_KEYS.has( k ) && !ADDRESS_ARG_KEYS.has( k ) ) parameters[ k ] = v
+      if( said ) parameters['gist'] = said
+      const targetName = knownEntityName( keid, state )
+      if( targetName ) parameters['targetEntityName'] = targetName
+
+      // Named at INFO because this is the seam where a decision to contact someone
+      // either becomes a competing intention or disappears. When a Will named a
+      // colleague seven times over ten minutes and he never heard from it, nothing
+      // in the logs could distinguish "the intent was never created" from "it was
+      // created and lost every competition" — the two have completely different
+      // fixes, and the archaeology to tell them apart needed state snapshots that
+      // sample too coarsely to catch a cycle.
+      logger.info(
+        `[executive] willed reach-out → ${ targetName ?? keid } ` +
+        `(named '${ named }' → ${ keid }, priority=${ priority.toFixed( 2 ) })`
+      )
+
       set.push({
         id:   `ideomotor-reach-out-${ keid }`,
         type: 'ideomotor.intent',
-        metadata: { schema: 'reach-out', targetEntityId: keid, priority, origin: 'executive', tick: footprint.tickObserved },
+        metadata: {
+          schema: 'reach-out', targetEntityId: keid,
+          ...( Object.keys( parameters ).length > 0 ? { parameters } : {} ),
+          priority, origin: 'executive', tick: footprint.tickObserved,
+        },
       })
       continue
     }
 
     // A host ability the executive imagines enacting, with its conscious args.
     const schema = externalBySchema.get( t )
-    if( !schema || seen.has(`ability:${ schema }`) ) continue
+    if( !schema ){
+      // The name resolves to NOTHING: not a communicate type, not an innate
+      // stance, not an ability the field affords. Record it so the mind can find
+      // out. Silence here is what let a Will spend eleven consecutive actions on
+      // an invented `query`, observe that nothing ever came of them, and conclude
+      // its MEMORY was broken — the one explanation that was not true.
+      if( !INNATE_SCHEMA_BY_ID.has( t ) ) unresolved.add( action.type )
+      continue
+    }
+    if( seen.has(`ability:${ schema }`) ) continue
     seen.add(`ability:${ schema }`)
     const keid = action.target ? resolveKnownEntity( action.target, state ) : undefined
     set.push({
@@ -454,6 +577,51 @@ function buildIdeomotorIntents(
     })
   }
 
+  // An action that named nothing is REPORTED, not swallowed.
+  //
+  // The executive's actions bias the agency competition; they are not commands, so
+  // a name that matches no schema is not a dispatch error and nothing downstream
+  // ever objected. But an unopposed no-op is indistinguishable from an act that
+  // was tried and achieved nothing, and the mind reasons from the difference.
+  // Observed: eleven consecutive `query` actions (a name that does not exist),
+  // then "five consecutive queries with no memory trace is a failure mode" and a
+  // plan to diagnose its own memory. Telling it the name was not real costs one
+  // entity and removes a whole class of false self-belief.
+  if( unresolved.size > 0 )
+    set.push({
+      id:   'action.unresolved',
+      type: 'action.unresolved',
+      metadata: {
+        names:   [ ...unresolved ],
+        summary: `I named ${ [ ...unresolved ].map( n => `'${ n }'` ).join(', ') } as an action, but ${ unresolved.size > 1 ? 'those are not things' : 'that is not a thing' } I can do — no such ability is in my repertoire or afforded right now. Nothing happened. To act I have to name something I actually have.`,
+        salience: 0.75,
+        origin:   'executive',
+        tick:     footprint.tickObserved,
+      },
+    })
+
+  // An addressee that resolves to nobody is REPORTED, not swallowed.
+  //
+  // Same principle as the unresolved-name report above, one layer down: there the
+  // *verb* named nothing, here the *person* does. The mind can hear a name in
+  // conversation ("coordinate that through FKEM") long before that name is bound
+  // to anyone it can actually reach, and reaching-out to an unbound name simply
+  // does not happen. Told, it can do the human thing — ask how to reach them, or
+  // ask whoever mentioned them to make the introduction. Untold, it believes it
+  // made contact and follows up on a message it never sent.
+  if( unaddressed.size > 0 )
+    set.push({
+      id:   'action.unaddressed',
+      type: 'action.unaddressed',
+      metadata: {
+        names:   [ ...unaddressed ],
+        summary: `I meant to reach ${ [ ...unaddressed ].map( n => `'${ n }'` ).join(', ') }, but ${ unaddressed.size > 1 ? 'those names match no one' : 'that name matches no one' } I know how to contact — no message went out. If I want to reach them I need a way to: someone can introduce us, or tell me where to find them.`,
+        salience: 0.8,
+        origin:   'executive',
+        tick:     footprint.tickObserved,
+      },
+    })
+
   // Clear stale executive-sourced intents the executive no longer imagines this cycle.
   const currentIds = new Set( set.map( s => s.id ) )
   const del: string[] = []
@@ -463,6 +631,13 @@ function buildIdeomotorIntents(
         && !currentIds.has( id ) )
       del.push( id )
 
+  // Clear the report once the mind names only real actions again — it should read
+  // as "that last attempt was not a thing", not as a permanent defect in itself.
+  if( unresolved.size === 0 && state.entities.has('action.unresolved') )
+    del.push('action.unresolved')
+  if( unaddressed.size === 0 && state.entities.has('action.unaddressed') )
+    del.push('action.unaddressed')
+
   return { set, delete: del }
 }
 

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

@@ -9,6 +9,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 +39,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>)    ?? {}
@@ -275,6 +284,37 @@ export async function buildExecutiveContext(
   recentActions.sort( ( a, b ) => b.tick - a.tick )
   const recentActionsCapped = recentActions.slice( 0, 5 )
 
+  // 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
+  }
+
+  // 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
   // progress, enabling it to target a specific plan by id when managing several. (P4)
@@ -328,6 +368,7 @@ export async function buildExecutiveContext(
     beliefs,
     beliefsOmitted,
     recentActions: recentActionsCapped,
+    spokenTurns,
     behavioralDisposition,
     selfTuning,
     knownEntities: extractKnownEntities( state ),
@@ -436,6 +477,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 +533,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 )

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