@mindot/will 0.8.0 → 0.9.0

package/src/cognition/config.mirror.entities.ts

@@ -13,6 +13,7 @@
 // reason about its own operational parameters.
 
 import { WillConfig } from '#stem/mind'
+import type { StateManager } from '#core/state.manager'
 
 export interface EngineConfigEntity {
   id:     string
@@ -316,6 +317,24 @@ export function buildEngineConfigEntities( config: WillConfig, executiveInterval
         // DOWN from demonstrated `analytical` disposition via the persona-prior mirror,
         // so a more analytical Will deliberates more readily; this is the baseline.
         deliberateThreshold: 0.5,
+        // How many focused facets this Will can hold at once before spawning starts
+        // evicting (FacetSupervisor). A structural ceiling, not the live budget:
+        // attention scales the allowance *within* it each tick, so a tired or loaded
+        // mind narrows on its own. The metacog loop develops it via the persona-prior
+        // (openness widens, conscientiousness narrows), which is what makes "how many
+        // things I can hold at once" a property of this person rather than a constant.
+        maxFacets: 10,
+        // How long a QUIET thread stays open before the mind considers it finished
+        // (FacetSupervisor idle reaper). The sibling of maxFacets — that one is how
+        // many threads at once, this one is how long each survives a silence — and
+        // it was the only number in the economy no personality could move.
+        //
+        // ~30 minutes at a typical tick rate. It was hardcoded at 50 ticks, which is
+        // THIRTY SECONDS: every pause longer than a person taking a moment to type
+        // destroyed the conversation, and the reply landed on a facet that had never
+        // heard of them. Generous is safe — maxFacets + eviction bound the population;
+        // this only decides when silence means "over".
+        facetIdleTtlTicks: 3000,
       },
     },
     {
@@ -366,6 +385,35 @@ export function buildEngineConfigEntities( config: WillConfig, executiveInterval
         switchCost:   0.15,
         riskWeight:   0.20,
         noveltyWeight: 0.10,
+        // How hard an act's own live footprint damps doing it again (EXAFFERENCE
+        // P5) — how long this mind sits with something it has already said before
+        // saying it again. Agreeableness develops it up, demonstrated persistence
+        // down, so "gives people room" vs "chases an answer" is a trait rather
+        // than a constant.
+        repeatDamping: 0.30,
+        // Ticks an act keeps satiating the urge to repeat it. Separate from the
+        // consequence TTL on purpose: that one is "how long until the world's echo
+        // could still arrive" (short, and about perception), this is "how long
+        // before saying it again feels right" (a disposition). Same two traits as
+        // repeatDamping move it — patience lengthens, persistence shortens.
+        repeatWindowTicks: 60,
+        // Ticks before a silence starts to mean something — how long this mind
+        // gives someone to get back to it before it counts the turn unanswered
+        // and learns from that (conversation.aim / ReafferenceEngine).
+        //
+        // Lives beside repeatWindowTicks rather than in a config of its own
+        // because they are two readings of ONE disposition, and splitting them
+        // would let a mind tune itself into contradiction — coming back to
+        // something in 20 ticks while still calling the silence too fresh to
+        // count. Long relative to its neighbours by design: repeatWindowTicks
+        // asks "how long before saying it again feels right", this asks "how long
+        // before I take not hearing back as information", and at 1s/tick that is
+        // four minutes of a real person's time, not one.
+        replyWindowTicks: 240,
+        // How much a learned read on someone biases acting toward them. SIGNED and
+        // unclamped: a warm mind leans toward whoever answers, a dogged one chases
+        // the silence. The container will not choose between those.
+        socialWeight:  0.30,
       },
     },
 
@@ -473,3 +521,63 @@ export function buildEngineConfigEntities( config: WillConfig, executiveInterval
     },
   ]
 }
+
+// ── The single writer ─────────────────────────────────────────
+
+/**
+ * Write an `engine.config` entity — MERGING, always. The only sanctioned way to
+ * write one; `tests/unit/config.mirror.writer.test.ts` fails on a raw
+ * `setEntity({ type: 'engine.config' })` anywhere else.
+ *
+ * Every whole-entity write to one of these has silently dropped params, three
+ * times in one day and each in a different place:
+ *
+ *   • PMALoader replaced `engine-config-executive` with the three behavioural
+ *     params a PMA carries, dropping `deliberateThreshold` — so `readBaseParams`
+ *     returned nothing for it and `consolidatePrior` skipped the analytical and
+ *     decisiveness edges outright, for every Will ever restored from an artifact.
+ *   • The same loader dropped `emitBlendEvents` from the blender and three params
+ *     from forgetting.
+ *   • Snapshot restore replaced the whole mirror, so a Will woke with the config
+ *     it FIRST hibernated under and could never receive a param added later —
+ *     `maxFacets` and `deliberateThreshold` were inert on a live Will for its
+ *     entire life.
+ *
+ * `precedence` says which side wins on a key both hold. Neither ever drops a key.
+ *
+ *   'incoming' — the caller is the authority (boot seed; a PMA supplying the
+ *                tenant's own dispositions). Keys it does not mention survive.
+ *   'existing' — state is the authority (post-restore backfill). Only genuinely
+ *                missing keys are added, so learned and PMA'd values are safe.
+ *
+ * Returns the keys it actually added or changed, for the caller to log.
+ */
+export function mergeEngineConfig(
+  store:      StateManager,
+  cfg:        EngineConfigEntity,
+  precedence: 'incoming' | 'existing' = 'incoming',
+): string[] {
+  const existing = store.getEntity( cfg.id )
+  const current  = ( existing?.metadata as { params?: Record<string, unknown> } | undefined )?.params ?? {}
+
+  const params = precedence === 'existing'
+    ? { ...cfg.params, ...current }   // state wins; fills only what is missing
+    : { ...current, ...cfg.params }   // caller wins; keeps everything else
+
+  const changed = Object.keys( params ).filter( k => params[ k ] !== current[ k ] )
+  if( existing && changed.length === 0 ) return []
+
+  // No timestamps: StateManager.setEntity is the single place they are stamped,
+  // and it sources them from the SIM clock so entity times replay identically
+  // (R2). It also preserves an existing `createdAt`. The write sites this
+  // replaced all passed `Date.now()`, which was both redundant and a real
+  // determinism hole — the guard test caught it the moment the code moved into
+  // `cognition/`, where wall-clock reads are banned.
+  store.setEntity({
+    id:       cfg.id,
+    type:     'engine.config',
+    metadata: { engine: cfg.engine, params },
+  })
+
+  return changed
+}

package/src/cognition/event.schemas.ts

@@ -566,3 +566,25 @@ globalSchemaRegistry.register({
     return hasNum( p, 'count')
   },
 })
+
+// ── Deliberation cache (fast-path telemetry) ─────────────────
+// Published from the ExecutiveEngine's committed path (onReasoningComplete),
+// never from inside the pure cache. Lets faculties like the PersonaConsolidator
+// react to how automatic the Will is becoming (e.g. a high hit rate could lower
+// the deliberate-effort threshold).
+
+globalSchemaRegistry.register({
+  type: 'cache.hit', version: 1,
+  validate( p ){
+    if( !isObj(p) ) return 'payload must be object'
+    return hasNum( p, 'confidence') ?? hasNum( p, 'neighborCount')
+  },
+})
+
+globalSchemaRegistry.register({
+  type: 'cache.miss', version: 1,
+  validate( p ){
+    if( !isObj(p) ) return 'payload must be object'
+    return hasNum( p, 'confidence')
+  },
+})

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