@mindot/will 0.8.0 → 0.10.0

package/src/cognition/faculties/autobiographical.narrator.ts

@@ -23,6 +23,7 @@ import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
 import { GenerativeModel } from '#cognition/generative.model'
 import { readEffectiveParams } from '#cognition/persona.prior'
 import { ExecutiveEngine } from '#faculties/executive.engine'
+import { identityCommand } from '#cognition/identity.entity'
 
 export interface AutobiographicalNarratorConfig {
   minIntervalTicks?: number
@@ -171,16 +172,10 @@ export class AutobiographicalNarrator implements SimulationEngine, CognitiveEngi
           for( const { key: trait, value: delta } of executiveOutput.identityUpdates.traits )
             updatedTraits[ trait ] = Math.max( 0, Math.min( 1, ( updatedTraits[ trait ] ?? 0.5 ) + delta ) )
 
-          commands.set!.push({
-            id: 'identity-self',
-            type: 'will.identity',
-            createdAt: existingIdentity.createdAt,
-            metadata: {
-              ...existingIdentity.metadata,
-              traits: updatedTraits,
-              version: ( ( existingIdentity.metadata?.version as number ) ?? 1 ) + 1,
-            },
-          })
+          commands.set!.push( identityCommand( state, {
+            traits: updatedTraits,
+            version: ( ( existingIdentity.metadata?.version as number ) ?? 1 ) + 1,
+          } ) )
         }
       }
 

package/src/cognition/faculties/circadian.oscillator.ts

@@ -41,7 +41,22 @@ export interface CircadianConfig {
   /** Whether external light signals entrain the oscillator */
   entrainable?: boolean
   /** Current simulated time of day in hours (0-24). If not provided, derived from tick. */
-  timeOfDayHours?: number
+  /**
+   * The hour of day, 0–24. A NUMBER freezes it; a FUNCTION is read every tick,
+   * which is what a host with a real clock should pass.
+   *
+   * WHY THIS IS THE HOST'S TO SUPPLY. Left unset, the oscillator derives the
+   * hour from the tick count (1 tick = 1 second), which makes it *hours since
+   * tick zero, mod 24* — and after a snapshot restore, tick zero is an
+   * arbitrary point in a previous life. A mind reasoning about whether anyone
+   * is awake right now was reasoning from that.
+   *
+   * A circadian oscillator is a BODY RHYTHM, not a clock. It models what a body
+   * does over a day; it cannot know what day it is or where on Earth it runs.
+   * What time it is, is a fact about the world — afference — and arrives the
+   * way `environment.light_level` already does: from whoever can see it.
+   */
+  timeOfDayHours?: number | ( () => number )
   bus?: CognitiveBus
 }
 
@@ -51,7 +66,7 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
   private _periodHours: number
   private _phaseOffsetHours: number
   private _entrainable: boolean
-  private _timeOfDayHours?: number
+  private _timeOfDayHours?: number | ( () => number )
 
   private _bus: CognitiveBus | null = null
 
@@ -100,8 +115,11 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
     events:   Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = [],
     commands: StateCommands = { metrics: [] }
 
-    // Determine current time of day
-    let timeOfDay = this._timeOfDayHours
+    // Determine current time of day. A function is re-read every tick — a host
+    // clock moves; a config value does not.
+    let timeOfDay = typeof this._timeOfDayHours === 'function'
+      ? normalizeHour( this._timeOfDayHours() )
+      : this._timeOfDayHours
 
     if( timeOfDay === undefined ){
       // Derive from tick, assuming 1 tick = 1 second
@@ -278,17 +296,28 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
    * Set the current time of day explicitly (for scenarios with controlled time).
    */
   setTimeOfDay( hours: number ): void {
-    this._timeOfDayHours = ( hours % 24 + 24 ) % 24
+    this._timeOfDayHours = normalizeHour( hours )
+  }
+
+  /** Read a live clock every tick instead of holding a fixed hour. */
+  setClock( clock: ( () => number ) | null ): void {
+    this._timeOfDayHours = clock ?? undefined
   }
 
   /**
    * Get the current circadian phase.
    */
   getPhase(): CircadianPhase {
-    const h = this._timeOfDayHours ?? 12
+    const h = typeof this._timeOfDayHours === 'function'
+      ? normalizeHour( this._timeOfDayHours() )
+      : this._timeOfDayHours ?? 12
     return h >= 6 && h < 12 ? 'morning'
          : h >= 12 && h < 17 ? 'afternoon'
          : h >= 17 && h < 21 ? 'evening'
          : 'night'
   }
-}
+}
+/** 0–24, wrapping — a host clock that hands over 25 or −1 must not poison the rhythm. */
+function normalizeHour( h: number ): number {
+  return Number.isFinite( h ) ? ( ( h % 24 ) + 24 ) % 24 : 12
+}

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

@@ -114,6 +114,13 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
 
   // Vector memory integration
   private _vectorMemory: VectorMemoryAdapter | null = null
+  /**
+   * In-flight background indexing. Indexing is deliberately not awaited inside
+   * react() (a rate-limit retry chain would stall the whole tick loop), so this is
+   * the handle for the two callers that genuinely must wait for it: shutdown,
+   * before persisting the index, and tests asserting on it.
+   */
+  private _indexing: Promise<void> = Promise.resolve()
   private _embedder: EmbeddingProvider | null = null
   private _autoIndex: boolean
 
@@ -278,7 +285,35 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
         content: ep.content
       } ) )
 
-      await this._vectorMemory.indexBatch( episodesWithContent )
+      // Indexing is BEST-EFFORT, exactly like semanticQuery. It calls an embedding
+      // provider, so a rate limit or an outage is an ordinary condition, not a
+      // cognitive fault: the episode is already consolidated and in the store, and
+      // only its vector is missing. Letting that throw took the whole engine down
+      // mid-tick — observed live as `Engine "episodic-consolidator" threw at tick
+      // 107: Embedding failed: 429`, which also aborted the rest of this react()
+      // (store sync, forgetting-curve decay) for that tick.
+      //
+      // The episode itself is NOT lost: it is in `_store` and is written to state by
+      // the periodic full-store sync below, so it survives snapshot/restore. Only its
+      // VECTOR is missing, which costs semantic recall of that episode for the rest of
+      // the session — `rebuildFromStore()` re-indexes the whole store on a later
+      // restore that finds no persisted index. Nothing re-indexes it in-session; that
+      // is a known gap, not a claim that this self-heals.
+      // NOT awaited. Nothing in this tick reads the vector index, and the embedding
+      // call is a network round-trip behind a rate-limit gate whose retry chain runs
+      // ~60s (4+8+16+32s) before giving up. Awaiting it made a single 429 stall the
+      // WHOLE TICK LOOP for a minute — measured: ticks 3→4 and 4→5 took 64.9s and
+      // 63.5s, one per deferred batch. That is not merely slow: `AWAIT_TIMEOUT` and
+      // every other agency deadline are denominated in TICKS, so a 60s tick silently
+      // turned a 15-tick timeout into 15 minutes, left one communicate intent stuck
+      // 'awaiting', and — because the selector is serial — blocked every subsequent
+      // action. 45 executive decisions produced 1 intent and 0 delivered messages.
+      this._indexing = this._vectorMemory.indexBatch( episodesWithContent ).catch( ( err: unknown ) => {
+        logger.warn(
+          `[EpisodicConsolidator] indexing deferred for ${ newEpisodes.length } episode(s) — ` +
+          `${ err instanceof Error ? err.message : String( err ) }`
+        )
+      } )
     }
 
     // 5. Periodic full-store sync — captures activationStrength decay (forgetting curve),
@@ -385,6 +420,9 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
    * Other metadata narrowing (sourceType / tags) remains the caller's job on the
    * returned episodes (which carry all metadata).
    */
+  /** Await any background indexing still in flight. Shutdown and tests only. */
+  async flushIndexing(): Promise<void> { await this._indexing }
+
   async semanticQuery(
     query: unknown,
     filters?: {
@@ -417,10 +455,18 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
     let timer: ReturnType<typeof setTimeout> | undefined
     const timedOut = Symbol('recall-timeout')
 
+    // The search keeps running after the race is lost — its own rate-limit retry
+    // chain can outlive this timeout by a minute. Its rejection is caught HERE
+    // rather than left to the race: a promise that loses a Promise.race still
+    // settles, and an unhandled 429 rejection surfaces as a process-level warning
+    // (or a crash, depending on host) long after the recall it belonged to gave up.
     const results = await Promise.race( [
       this._vectorMemory.search( query, {
         maxResults:    fetch,
         minSimilarity: filters?.minSimilarity,
+      } ).catch( ( err: unknown ) => {
+        logger.warn(`[EpisodicConsolidator] recall search failed — ${ err instanceof Error ? err.message : String( err ) }`)
+        return []
       } ),
       new Promise<typeof timedOut>( resolve => { timer = setTimeout( () => resolve( timedOut ), timeoutMs ) } ),
     ] ).finally( () => clearTimeout( timer ) )
@@ -658,8 +704,18 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
     if( this._vectorMemory ){
       await this._vectorMemory.load()
       if( this._vectorMemory.size === 0 && this._store.length > 0 ){
-        await this._vectorMemory.rebuildFromStore( this._store )
-        logger.info(`[episodic] vector index rebuilt with ${this._store.length} episodes`)
+        // Re-embedding the whole store is a bulk network operation, and this runs on
+        // the FIRST TICK after restore. Awaited, it held tick 1 for 66.7s against a
+        // 500ms budget and threw on a rate limit — a mind spending its first waking
+        // minute frozen, with every tick-denominated deadline stretched around it.
+        // Detached: recall degrades to "not yet indexed" until it lands, which is the
+        // same best-effort contract semanticQuery already has. `flushIndexing()` is
+        // what shutdown drains, so a rebuild in flight is still written out.
+        this._indexing = this._vectorMemory.rebuildFromStore( this._store )
+          .then( () => { logger.info(`[episodic] vector index rebuilt with ${ this._store.length } episodes`) } )
+          .catch( ( err: unknown ) => {
+            logger.warn(`[episodic] vector index rebuild deferred — ${ err instanceof Error ? err.message : String( err ) }`)
+          } )
       } else if( this._vectorMemory.size > 0 ){
         logger.info(`[episodic] vector index loaded from disk (${this._vectorMemory.size} entries)`)
       }

package/src/cognition/faculties/executive.engine/action.record.ts

@@ -0,0 +1,129 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/faculties/executive.engine/action.record.ts
+// ─────────────────────────────────────────────────────────────
+//
+// What became of what I did.
+//
+// The executive's prompt has a `## What Became Of What I Did` section (called
+// `## Recent Action Outcomes` until P3 renamed it after what it renders), a builder
+// for it, and a type for its data. `context.ts` fills it by scanning
+// `decision.record` entities that carry an `actionStatus`. Nothing in the engine
+// has ever written `actionStatus` — it is read in exactly one place and set in
+// none — so the section has never had a single row. Measured across every
+// prompt a live COO received over two runs: that section appears
+// 0 times, while `## What I've Said Lately` appears in all of them.
+//
+// So the mind could see what it had SAID and never what it had DONE. Its only
+// other record of its own doing is `## What I Have Been Choosing` (`## Recent
+// Actions` at the time), which is fed from
+// `output.actions` — the executive's DECISIONS — and is therefore a list of
+// intentions wearing the name of a history.
+//
+// A mind whose record of acting contains only intentions cannot tell an
+// intention from an act. Live, asked directly "have you completed that?", a COO
+// answered "Yes — it's done. I drafted the full v0.1 spec: user stories, command
+// surface, integration points, success metrics. Posted it to FKEM." She had
+// posted nothing; she had no effectors at all and could not have drafted
+// anything anywhere. Her deliberation history said "I produce the scoping doc
+// now" across twenty cycles, and nothing in her state said whether she had.
+//
+// This is the same distinction `pending` draws for utterances — attempting to
+// speak is not speaking (#124) — carried to acts in general. It is written from
+// the `action.outcome` the executive ALREADY receives (it subscribes to `*`) and
+// from an explicit withheld signal, and it is an ordinary entity, so it
+// snapshots and replays with the rest of the mind.
+// ─────────────────────────────────────────────────────────────
+
+import type { EntityInput, Tick } from '#core/types'
+
+export const ACTION_RECORD_TYPE = 'action.record'
+
+/**
+ * How many outcomes the mind carries.
+ *
+ * Matches the cap `context.ts` already applies when rendering, so the state
+ * holds what the prompt shows and no more — an unbounded history of everything
+ * ever done is a memory system, not a working record, and this is the latter.
+ */
+export const ACTION_RECORD_KEEP = 6
+
+/**
+ * `withheld` is a first-class outcome, not a flavour of failure.
+ *
+ * The mind considered an act, formed it, and chose not to complete it. Folding
+ * that into `failed` is the mistake #123 was written to correct — it taught a
+ * COO it was bad at speaking from the times it decided not to speak.
+ */
+export type ActionStatus = 'completed' | 'failed' | 'withheld'
+
+export interface ActionRecord {
+  type:            string
+  status:          ActionStatus
+  tick:            Tick
+  targetEntityId?: string
+  /** The mind's own account of what happened, in its words where it has any. */
+  outcome:         string
+  planId?:         string
+}
+
+/** Stable id — one record per (tick, act), so two acts on a tick both survive. */
+export function actionRecordId( tick: Tick, type: string, targetEntityId?: string ): string {
+  return `action-record-${ tick }-${ type }${ targetEntityId ? `-${ targetEntityId }` : '' }`
+}
+
+export function actionRecordEntity( r: ActionRecord ): EntityInput {
+  return {
+    id:   actionRecordId( r.tick, r.type, r.targetEntityId ),
+    type: ACTION_RECORD_TYPE,
+    metadata: { ...r },
+  }
+}
+
+/** Read a record back off entity metadata — every field, including the ones it is easy to forget. */
+export function readActionRecord(
+  m: ReadonlyMap<string, unknown> | Record<string, unknown> | undefined,
+): ActionRecord | null {
+  const meta = ( m instanceof Map ? Object.fromEntries( m ) : m ?? {} ) as Record<string, unknown>
+  const type   = typeof meta['type'] === 'string' ? meta['type'] as string : undefined
+  const status = meta['status']
+  if( !type || ( status !== 'completed' && status !== 'failed' && status !== 'withheld') ) return null
+
+  return {
+    type, status,
+    tick:           typeof meta['tick'] === 'number' ? meta['tick'] as number : 0,
+    targetEntityId: typeof meta['targetEntityId'] === 'string' ? meta['targetEntityId'] as string : undefined,
+    outcome:        typeof meta['outcome'] === 'string' ? meta['outcome'] as string : '',
+    planId:         typeof meta['planId'] === 'string' ? meta['planId'] as string : undefined,
+  }
+}
+
+/** The mind's recent acts, newest first. */
+export function recentActionRecords(
+  entities: ReadonlyMap<string, { type: string; metadata?: ReadonlyMap<string, unknown> | Record<string, unknown> }>,
+  keep:     number = ACTION_RECORD_KEEP,
+): ActionRecord[] {
+  const out: ActionRecord[] = []
+  for( const [ , e ] of entities ){
+    if( e.type !== ACTION_RECORD_TYPE ) continue
+    const r = readActionRecord( e.metadata )
+    if( r ) out.push( r )
+  }
+  // Newest first, ties broken by act name so a run and its replay agree.
+  out.sort( ( a, b ) => b.tick - a.tick || ( a.type < b.type ? -1 : a.type > b.type ? 1 : 0 ) )
+  return out.slice( 0, keep )
+}
+
+/** Records that have fallen off the end of the window — swept by the writer. */
+export function staleActionRecordIds(
+  entities: ReadonlyMap<string, { type: string; metadata?: ReadonlyMap<string, unknown> | Record<string, unknown> }>,
+  keep:     number = ACTION_RECORD_KEEP,
+): string[] {
+  const all: Array<{ id: string; r: ActionRecord }> = []
+  for( const [ id, e ] of entities ){
+    if( e.type !== ACTION_RECORD_TYPE ) continue
+    const r = readActionRecord( e.metadata )
+    if( r ) all.push({ id, r })
+  }
+  all.sort( ( a, b ) => b.r.tick - a.r.tick || ( a.r.type < b.r.type ? -1 : a.r.type > b.r.type ? 1 : 0 ) )
+  return all.slice( keep ).map( x => x.id )
+}

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 }
 }