@mindot/will 0.8.0 → 0.10.0

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

@@ -59,6 +59,18 @@ export interface ExecutiveOutputFull {
     name?:    string
     learned?: string[]
     feeling?: number
+    /**
+     * "This is the same someone as that" — another keid I now believe is this
+     * same referent, fusing two of my records into one.
+     *
+     * The mind's own verdict on an identity, and it may do what the recognition
+     * heuristic will not: absorb an ESTABLISHED relationship. The heuristic is
+     * right to refuse — fusing two real people who share a name would take one of
+     * them's whole history — but the mind has evidence a name-match does not,
+     * usually because somebody just told it. Without this, the same human
+     * well-established on two channels stayed two people permanently.
+     */
+    sameAs?:  string
   }>
   newGoals?: Array<{
     description: string
@@ -70,6 +82,8 @@ export interface ExecutiveOutputFull {
   goalsToAbandon?: Array<{ goalId: string; reason: string }>
   goalsToReprioritize?: Array<{ goalId: string; newPriority: number; reason: string }>
   selfObservations?: string[]
+  /** Compound actions the mind is naming as single skills (see ProposedSkill). */
+  newSkills?: ProposedSkill[]
   /**
    * Plain-text reply from a conversation facet — populated by parseResponse()
    * from the [REPLY_TEXT]...[/REPLY_TEXT] block.
@@ -78,14 +92,10 @@ export interface ExecutiveOutputFull {
    */
   replyText?: string
   /**
-   * @deprecated Legacy JSON reply format — no longer emitted by conversation facets.
-   * Kept for backward compatibility with any tests/tooling that inspect parsed output.
+   * Set when the facet declared it is NOT speaking this cycle, carrying why.
+   * Present ⇒ nothing is sent, whatever else the response contains.
    */
-  conversationReplies?: Array<{
-    targetEntityId: string
-    targetEntityName: string
-    messages: string[]
-  }>
+  noMessage?: string
   /**
    * System 2 only — the distinct approaches the master generated and weighed before
    * committing, retained for explainability/auditability (and a future regret /
@@ -235,8 +245,11 @@ export interface ExecutiveContext {
   relevantPlanIds: string[]
   percepts: Array<{
     category: string
+    /** The engine's label for the signal. */
     summary: string
     salience: number
+    /** What the host actually sent, whole — the evidence under the label. */
+    data?: unknown
   }>
   /**
    * Host-declared abilities afforded to the Will *right now* — what it can do in
@@ -253,8 +266,11 @@ export interface ExecutiveContext {
   }>
   workingMemory: Array<{
     type: string
+    /** The engine's label for the item. */
     summary: string
     activation: number
+    /** What a host sent, whole — carried through memory, not only into it. */
+    data?: unknown
   }>
   memories: Array<{
     content: string
@@ -271,15 +287,21 @@ export interface ExecutiveContext {
   /** How many beliefs exist but were not included due to the relevance cap. */
   beliefsOmitted: number
   /**
-   * Recent action outcomes — shows the executive what it already tried and whether it
-   * landed.  Built from `decision.record` entities with an `actionStatus` set.
-   * Surfaces the Act→Confirm→Perceive feedback loop into the executive's reasoning.
+   * What became of what it did — the Act→Confirm→Perceive loop, surfaced.
+   *
+   * Built from `action.record` entities the executive writes from the
+   * `action.outcome` / `action.withheld` events it already receives. It used to
+   * be built from `decision.record` entities carrying an `actionStatus`, a field
+   * read in one place and written in none — so this was empty in every prompt a
+   * live mind ever received, and it could see what it had SAID but never what it
+   * had DONE. See `action.record.ts`.
    */
   recentActions: Array<{
     /** Effector name that was invoked */
     type: string
-    /** Lifecycle status set by ActionExecutor */
-    status: 'completed' | 'failed' | 'awaiting_host' | 'timed_out'
+    /** How it resolved. `withheld` is distinct from `failed` on purpose: the
+     *  mind formed the act and chose not to complete it. */
+    status: 'completed' | 'failed' | 'withheld'
     /** Tick the action was executed or dispatched */
     tick: number
     /** Short outcome description — truncated to 120 chars */
@@ -287,6 +309,33 @@ export interface ExecutiveContext {
     /** planId if this action came from a plan step */
     planId?: string
   }>
+  /**
+   * What the mind has said to people lately, and who has answered.
+   *
+   * The one thing it could never see about itself. `conversation.sent` has been in
+   * state since the beginning — 57 records on the Will this was found on — and
+   * reached no prompt at all, so the sole evidence of having spoken was a `✓
+   * reach-out` line under What Became Of What I Did: no words, no person, and a tick
+   * mark asserting it had worked. That is why the same question went out eleven
+   * times in two and a half minutes; from the inside each one was the first.
+   *
+   * Newest first. Answered turns are kept alongside open ones deliberately — "I
+   * asked and they replied" and "I asked and heard nothing" only mean anything
+   * against each other.
+   */
+  spokenTurns: Array<{
+    /** Who it was said to, by name where the mind knows one. */
+    target:  string
+    /** The opening words — enough to recognise a thing already said. */
+    preview: string
+    /** Ticks since it was said. */
+    age:     number
+    /** Unset while still in the air; the mind is told which. */
+    answered: boolean
+    /** What they said back, when they did. The fact of an answer without its
+     *  content is worse than silence — it invites acting as though it is known. */
+    answeredWith?: string
+  }>
   /** Behavioral disposition loaded from PMA at session start — stable per session. */
   behavioralDisposition?: {
     riskTolerance:   number
@@ -309,6 +358,10 @@ export interface ExecutiveContext {
    * Omitted when the Will knows no one.
    */
   knownEntities?: Array<{
+    /** Where this referent is reachable, and how each place has gone. */
+    handles?: Array<{ keid: string; kind: string; answeredAgo?: number }>
+    /** Names of referents this one may be the same as — an unsettled identity. */
+    mayBeSameAs?: string[]
     keid:            string
     kind:            'sentient' | 'thing'
     name?:           string
@@ -336,6 +389,25 @@ export interface ExecutiveContext {
 
 // ── Pending message ──────────────────────────────────────────
 
+/**
+ * A compound action the mind names as one thing it does — "when I do A then B,
+ * that is <name>". Registered into the SchemaRepertoire as a composite, after
+ * which it competes as a single affordance and can proceduralize into a habit.
+ *
+ * This is the creation seam for the instrumental→habitual gradient. Before it,
+ * `agency.composite.proposed` was subscribed by ReafferenceEngine — whose handler
+ * is the only caller of `registerComposite()` anywhere — and published by nothing,
+ * so no Will could ever hold a skill beyond the innate floor (#114).
+ */
+export interface ProposedSkill {
+  /** What the mind calls it. Becomes the schema id. */
+  id: string
+  /** The sub-schemas it is made of, in order. Two or more, or it is not compound. */
+  composedOf: string[]
+  tags?: string[]
+  cost?: number
+}
+
 export interface PendingMessage {
   id: string
   content: string

package/src/cognition/faculties/exteroception.ts

@@ -24,18 +24,18 @@ import type {
   SimulationContext,
   ReadonlySimulationState,
   StateCommands,
-  SimulationEvent,
   SimulationEntity,
 } from '#core/types'
 import type { SimulationEngine, EngineResult, CognitiveEngine } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
+import { perceptEntity, PERCEPT_SUMMARY_CAP } from '#cognition/percept.entity'
 import { GenerativeModel } from '#cognition/generative.model'
 import {
-  CONSEQUENCE_TYPE, ATTENUATION, CORRESPONDENCE_ATTENUATION,
+  ATTENUATION, CORRESPONDENCE_ATTENUATION,
   liveConsequences, matchConsequenceText, matchConsequenceEntity,
 } from '#agency/consequence'
-import { REVOCATION_TYPE } from '#agency/revocation'
+import { MIND_OWN_ENTITY_TYPES } from '#cognition/sense.boundary'
 
 export interface ExteroceptionConfig {
   /** Maximum percepts to produce per tick */
@@ -43,9 +43,18 @@ export interface ExteroceptionConfig {
   /** Default salience for unmarked percepts */
   defaultSalience?: number
   /** Whether to emit percept events */
-  emitPerceptEvents?: boolean
   /** Entity types to always treat as high-salience */
   highPriorityTypes?: string[]
+  /**
+   * Where this mind ends — the entity types its own engines write about its own
+   * operation, which it therefore cannot encounter as world events. Live, so a
+   * host adding a cognitive engine after assembly is accounted for.
+   *
+   * Unwired (a bare harness, a unit test) it falls back to the shipped anatomy,
+   * which is right for every assembly that adds no cognitive engine of its own.
+   * See `#cognition/sense.boundary`.
+   */
+  endogenous?: () => ReadonlySet<string>
   bus?: CognitiveBus
 }
 
@@ -63,51 +72,60 @@ interface RawPercept {
   valenceSource?: 'entity' | 'ambient'
 }
 
-// Skip internal entities — they're not external percepts.
-// Percepts about percepts create a feedback loop that floods
-// working memory and episodic storage with noise.
-const internalTypes = new Set([
-  'percept', 'percept.social', 'working_memory.item',
-  'interoception', 'attention.focus', 'decision.record',
-  'task.focus', 'self_observation',
-  'goal', 'belief', 'plan', 'narrative_chapter',
-  'introspection', 'self_narrative', 'cognitive_bias',
-  'effector.created', 'empathic_state', 'attachment.bond',
-  'theory_of_mind', 'reputation', 'episodic_memory',
-  // Internal state entities written by our own engines — not external events
-  'affect.blends', 'executive.summary',
-  // The agency's own forward-model records (EXAFFERENCE P1/P2): perceiving our
-  // expected-consequence descriptors would be a self-noise loop.
-  CONSEQUENCE_TYPE,
-  // The agency's own revocation tombstones (EXAFFERENCE P4) — internal bookkeeping.
-  REVOCATION_TYPE,
-])
-
 export class Exteroception implements SimulationEngine, CognitiveEngine {
   readonly name     = 'exteroception'
   
   private _maxPerceptsPerTick: number
   private _defaultSalience: number
-  private _emitPerceptEvents: boolean
   private _highPriorityTypes: Set<string>
-  private _previousEntityVersions = new Map<string, number>()  // entityId → updatedAt
+  /**
+   * entityId → what was last seen of it. The TYPE is remembered alongside the
+   * version because a removal has to answer the same question an appearance
+   * does — "was this mine?" — and by then the entity is gone. It used to be
+   * answered by a second, separately-drifting list of id prefixes.
+   */
+  private _previousEntityVersions = new Map<string, { at: Timestamp; type: string }>()
 
   private _bus: CognitiveBus | null = null
 
   private readonly _model    = new GenerativeModel()
 
+  /** Live sense boundary + a memo, so a 50-engine union isn't rebuilt per tick. */
+  private _boundary: ( () => ReadonlySet<string> ) | null
+  private _endogenousMemo: ReadonlySet<string> = MIND_OWN_ENTITY_TYPES
+
 
   constructor( config: ExteroceptionConfig = {} ){
     this._bus = config.bus ?? null
+    this._boundary = config.endogenous ?? null
     this._maxPerceptsPerTick = config.maxPerceptsPerTick ?? 50
     this._defaultSalience    = config.defaultSalience    ?? 0.3
-    this._emitPerceptEvents  = config.emitPerceptEvents  ?? true
     this._highPriorityTypes  = new Set( config.highPriorityTypes ?? [
       'message', 'notification', 'alert', 'threat', 'goal',
     ])
   }
   attachBus( bus: CognitiveBus ): void { this._bus = bus }
 
+  /**
+   * Wire the live sense boundary. Separate from construction because the
+   * boundary is derived from the assembled engine list, and this sense is
+   * constructed before that list exists (same reason `attachBus` exists).
+   */
+  attachBoundary( resolve: () => ReadonlySet<string> ): void { this._boundary = resolve }
+
+  /**
+   * The types that are THIS mind rather than its world.
+   *
+   * Re-read each tick so a host engine registered after assembly still lands
+   * inside the boundary; the memo makes that a set-identity check in the common
+   * case, since `endogenousTypes` returns the shipped set unchanged when nothing
+   * extra is declared.
+   */
+  private _endogenous(): ReadonlySet<string> {
+    if( this._boundary ) this._endogenousMemo = this._boundary()
+    return this._endogenousMemo
+  }
+
   // ── Engine interface ─────────────────────────────────────
 
   subscribes(): string[] { return ['executive.prediction.formed'] }
@@ -132,9 +150,7 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
     state: ReadonlySimulationState,
     context: SimulationContext
   ): Promise<EngineResult> {
-    const
-    events:   Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = [],
-    commands: StateCommands = { set: [], delete: [], metrics: [] }
+    const commands: StateCommands = { set: [], delete: [], metrics: [] }
 
     const rawPercepts = this._scanWorld( state )
 
@@ -168,37 +184,27 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
         : entityHit ? rp.salience * CORRESPONDENCE_ATTENUATION
         : rp.salience
 
-      const perceptEntity = {
-        id: `percept-${tick}-${i}`,
-        type: 'percept',
-        metadata: {
-          entityId: rp.entityId,
-          changeType: rp.changeType,
-          salience,
-          category: rp.category,
-          summary: rp.summary,
-          provenance: hit ? 'reafferent' : 'exafferent',
-          ...( hit ? { sourceIntentId: hit.intentId } : {} ),
-          // affect→percept seam (registry #5): what this percept FEELS like
-          ...( rp.valence !== undefined ? { valence: rp.valence, valenceSource: rp.valenceSource } : {} ),
-          tick,
-        },
-      }
-
-      commands.set!.push( perceptEntity )
-
-      // Emit percept event for downstream engines
-      if( this._emitPerceptEvents )
-        events.push({
-          type: `percept.${rp.changeType}.${rp.category}`,
-          source: this.name,
-          payload: {
-            entityId: rp.entityId,
-            salience,
-            category: rp.category,
-            summary: rp.summary,
-          },
-        })
+      // Through the shared constructor (SIGNAL_BOUNDARY P0) rather than a
+      // hand-rolled literal. A no-op here — this writer already set every core
+      // field — which is exactly why it is the one that proves the shape: four
+      // other writers reach it having each forgotten a different one.
+      //
+      // `provenance` is INFERRED here, legitimately: a match against our own
+      // live consequence descriptors is the efference copy doing its job. The
+      // sense door asserts instead, because it has nothing to match against.
+      commands.set!.push( perceptEntity( {
+        id:         `percept-${tick}-${i}`,
+        tick,
+        salience,
+        category:   rp.category,
+        summary:    rp.summary,
+        provenance: hit ? 'reafferent' : 'exafferent',
+        entityId:   rp.entityId,
+        changeType: rp.changeType,
+        ...( hit ? { sourceIntentId: hit.intentId } : {} ),
+        // affect→percept seam (registry #5): what this percept FEELS like
+        ...( rp.valence !== undefined ? { valence: rp.valence, valenceSource: rp.valenceSource } : {} ),
+      } ) )
     }
 
     // Clean up old percepts from previous ticks (keep last 2 ticks of percepts)
@@ -211,13 +217,12 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
     )
 
 
-    // Phase C + F: publish cognitive event — gated by prediction error
+    // The percept RATE is still learned — `percept.rate` carries a precision set
+    // from `executive.prediction.formed`, and the observation is what keeps that
+    // baseline honest. What is gone is the `percept.batch.ingested` event it used
+    // to publish: one publisher, zero subscribers, ever.
     const _bus = this._bus
-    if( _bus && capped.length > 0 ){
-      const predErr = this._model.observe('percept.rate', capped.length )
-      if( !predErr.gated )
-        _bus.publish({ type: 'percept.batch.ingested', version: 1, sourceEngine: this.name, salience: Math.max( 0.2, predErr.salience ), payload: { count: capped.length } })
-    }
+    if( capped.length > 0 ) this._model.observe('percept.rate', capped.length )
 
     // percept.category.updated — one event per distinct category so subscribers
     // (aesthetic.evaluator etc.) get a structured signal without scanning percepts
@@ -229,7 +234,7 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
         _bus.publish({ type: 'percept.category.updated', version: 1, sourceEngine: this.name, salience: Math.min( 1, count * 0.15 + 0.2 ), payload: { category, count } })
     }
 
-    return { events: events.length > 0 ? events : undefined, commands }
+    return { commands }
   }
 
   // ── Internal ─────────────────────────────────────────────
@@ -243,18 +248,19 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
 private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
     const percepts: RawPercept[] = []
     const currentIds = new Set<string>()
+    const mine       = this._endogenous()
 
     for( const [ id, entity ] of state.entities ){
       currentIds.add( id )
 
-      if( internalTypes.has( entity.type ) ){
-        // Still track the version so we don't get "appeared" events
-        // when these internal entities are first created
-        this._previousEntityVersions.set( id, entity.updatedAt )
+      if( mine.has( entity.type ) ){
+        // Still track it, so it never reads as "appeared" if the boundary later
+        // widens — but it is machinery, not world, and is not perceived.
+        this._previousEntityVersions.set( id, { at: entity.updatedAt, type: entity.type } )
         continue
       }
 
-      const previousVersion = this._previousEntityVersions.get( id )
+      const previousVersion = this._previousEntityVersions.get( id )?.at
 
       if( previousVersion === undefined ){
         percepts.push({
@@ -279,32 +285,27 @@ private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
         })
       }
 
-      this._previousEntityVersions.set( id, entity.updatedAt )
+      this._previousEntityVersions.set( id, { at: entity.updatedAt, type: entity.type } )
     }
 
-    // Detect removed entities (not internal types)
-    for( const [ id ] of this._previousEntityVersions ){
-      if( !currentIds.has( id ) ){
-        // Only report removal of meaningful entities
-        // We can't check the type here since the entity is gone,
-        // but we can infer from the ID prefix
-        if( !id.startsWith('percept-') 
-            && !id.startsWith('wm-')
-            && !id.startsWith('attention-')
-            && !id.startsWith('decision-')
-            && !id.startsWith('interoception-')
-            && !id.startsWith('task-')
-            && !id.startsWith('self-obs-') ){
-          percepts.push({
-            entityId: id,
-            changeType: 'removed',
-            salience: 0.4,
-            category: 'removed',
-            summary: `Entity removed: ${id}`,
-          })
-        }
-        this._previousEntityVersions.delete( id )
-      }
+    // Something that was there is gone. The same question as an appearance —
+    // was it mine or the world's? — and answerable now because the remembered
+    // type outlives the entity. It used to be guessed from a handful of id
+    // prefixes, which is why 17,802 of one quiet run's 36,721 percepts were the
+    // mind watching its own affordance field be torn down each tick.
+    for( const [ id, seen ] of this._previousEntityVersions ){
+      if( currentIds.has( id ) ) continue
+
+      if( !mine.has( seen.type ) )
+        percepts.push({
+          entityId: id,
+          changeType: 'removed',
+          salience: 0.4,
+          category: 'removed',
+          summary: `Entity removed: ${id}`,
+        })
+
+      this._previousEntityVersions.delete( id )
     }
 
     percepts.sort( ( a, b ) => b.salience - a.salience )
@@ -374,7 +375,7 @@ private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
         ? `${name} appears` : `${name} changed`
     }
     if( description ){
-      return description.slice( 0, 100 )
+      return description.slice( 0, PERCEPT_SUMMARY_CAP )
     }
 
     return `New ${entity.type}: ${entity.id.slice(0, 30)}`