@mindot/will 0.9.0 → 0.10.0

package/src/stem/tracts/outbox.controller.ts

@@ -91,24 +91,37 @@ export class OutboxController {
       break
     }
 
-    // 2. Write a percept so Exteroception perceives delivery ("ear hears the word")
-    instance.simulation.stateManager.setEntity({
-      id:        `msg-delivered-${messageId}`,
-      type:      'percept',
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      metadata: {
-        category:   'message-delivery',
-        summary:    delivered
-          ? `My message was delivered successfully.`
-          : `My message failed to reach the recipient.`,
-        salience:   delivered ? 0.35 : 0.6,
-        changeType: delivered ? 'delivered' : 'failed',
-        // Reafference by construction — this percept describes our own action's
-        // outcome ("ear hears the word"). Tagged, not attenuated: it is the ack
-        // surface, not a content echo (EXAFFERENCE P2).
-        provenance: 'reafferent',
+    // 2. The world's answer about my own words — in through the sense door.
+    //
+    // SIGNAL_BOUNDARY P4. This tract used to build the percept entity itself and
+    // `setEntity` it, which made it one of three places outside a sense that
+    // wrote a percept. It is reafference by construction ("the ear hears the
+    // word you spoke"): the message went out, and the world said whether it
+    // landed. That is precisely what the somatosensation door carries since P2,
+    // and going through it means the percept is stamped, traced and swept by the
+    // same machinery as every other one instead of by hand here.
+    //
+    // The facts go as `data`, not as prose. `delivered` and the id are what the
+    // mind has to reason from; the sentence it reads is the engine's business.
+    // Two deliveries in one tick stay distinct because `messageId` is in the
+    // data and the trace id hashes the label the data composes — identical
+    // payloads in one tick are what that hash is meant to collapse.
+    //
+    // `summary` here is a host-style hint, and the engine may bound it; the data
+    // beside it is never bounded. Salience keeps the old asymmetry — a failure
+    // is worth more attention than a success, because only one of them needs
+    // anything done about it.
+    void instance.cognition.somatosensationEngine.sense({
+      kind:       'system',
+      signal:     'message_delivery',
+      provenance: 'reafferent',
+      data: {
         messageId,
+        delivered,
+        salience: delivered ? 0.35 : 0.6,
+        summary:  delivered
+          ? 'My message was delivered successfully.'
+          : 'My message failed to reach the recipient.',
       },
     })
 

package/src/stem/tracts/sensory.controller.ts

@@ -4,7 +4,7 @@
 //
 // SensoryController owns the senses input + LLM chunk-streaming output
 // boundary extracted from WillStem (R5-e):
-//   - input ingestion: ingestText / ingestSensory / injectEvent
+//   - input ingestion: senseText / senseSignal / injectEvent
 //   - real-time chunk streaming: addChunkListener / addSensoryChunkListener
 //     and their sync helpers (syncChunkBroadcaster + the addChunkCallback fan-out)
 //
@@ -34,17 +34,17 @@ export class SensoryController {
    * LanguagePercept publication, conversation-facet spawn/reuse, and LLM
    * reply generation. Reply delivery is async via the outbox / SSE channel.
    */
-  async ingestText( instance: WillInstance, input: TextMessage ): Promise<void> {
-    await instance.cognition.auditionEngine.ingest( input )
+  async senseText( instance: WillInstance, input: TextMessage ): Promise<void> {
+    await instance.cognition.auditionEngine.sense( input )
   }
 
   /**
    * Route a raw SensoryInput to the appropriate sense engine by domain.
    * Used by the debug `POST /senses/:domain/ingest` route.
    */
-  async ingestSensory( instance: WillInstance, domain: string, input: SensoryInput ): Promise<void> {
+  async senseSignal( instance: WillInstance, domain: string, input: SensoryInput ): Promise<void> {
     const cog = instance.cognition
-    const engineMap: Record<string, { ingest: (i: SensoryInput) => Promise<void> }> = {
+    const engineMap: Record<string, { sense: (i: SensoryInput) => Promise<void> }> = {
       audition:        cog.auditionEngine,
       vision:          cog.visionEngine,
       somatosensation: cog.somatosensationEngine,
@@ -53,7 +53,7 @@ export class SensoryController {
     }
     const engine = engineMap[ domain ]
     if( !engine ) throw Object.assign( new Error(`Unknown sense domain: ${domain}`), { code: 400 } )
-    await engine.ingest( input )
+    await engine.sense( input )
   }
 
   /**

package/src/stem/tracts/session.logger.ts

@@ -50,7 +50,12 @@ export type LogEntryType =
   | 'executive.facet.destroy'
   | 'action.execute'
   | 'action.error'
-  | 'action.outcome'
+  // A HOST ACKED AN EFFECTOR — not the `action.outcome` BUS EVENT, which is a
+  // different shape with six subscribers (SIGNAL_BOUNDARY P3). The two shared
+  // this string, and the prompt section named after it renders a third thing
+  // again. One word, three shapes; this is the one that gives it up, because
+  // "a host acked" is what it actually records and nothing else logs it.
+  | 'effector.acked'
   | 'belief.integrate'
   | 'conversation.in'
   | 'conversation.out'

package/src/stem/tracts/transport/types.ts

@@ -29,7 +29,7 @@ interface BaseEnvelope {
   /**
    * Stable id used to match an outbound envelope to its ack(s).
    * For messages this is the OutboxMessage id; for effector invocations the
-   * decisionRecordId; for replies/chunks a generated id.
+   * intentId; for replies/chunks a generated id.
    */
   correlationId: string
   /** Monotonic per-Will sequence number — ordering + dedup at the peer. */
@@ -123,6 +123,25 @@ export interface InboundMessageEnvelope extends BaseEnvelope {
   threadId:   string
   content:    string
   speakerName?: string
+  /**
+   * Whose doing this was, as the SENDING host asserts it. Optional on the wire
+   * and only there: `SensoryInput.provenance` is required inside the package,
+   * but a wire type cannot make an older peer send a field, so absence has to
+   * be survivable. It is read through `asProvenance()`, which owns the
+   * direction for untyped ingress.
+   *
+   * This field is why the transport no longer says `'unknown'`. It used to,
+   * and correctly — the absence was STRUCTURAL, there was no field to fill —
+   * but `unknown` percepts are skipped by the rupture gate in `action.selector`,
+   * so a mind reached over a transport could not be interrupted by anyone
+   * speaking to it, while the same words in-process could interrupt it. Two
+   * transports, two different minds.
+   */
+  provenance?: import('#senses/index').SignalProvenance
+  /** True when this thread is private — just this someone and the Will. */
+  direct?:     boolean
+  /** What the room is called, e.g. `#general`. A label, not an address. */
+  threadName?: string
 }
 
 /** A non-conversational external percept (webhook, system signal, etc.). */

package/src/stem/tracts/transport.controller.ts

@@ -23,6 +23,7 @@
 import { logger } from '#core/logger'
 import { wallClock } from '#core/wall.clock'
 import { getInboundRecorder, getInboundSource } from '#core/inbound.recorder'
+import { asProvenance } from '#senses/index'
 import type { SensoryInput } from '#senses/index'
 import type { effectorInvocation, OutboxMessage } from '#types'
 import type { WillInstance } from '#stem/index'
@@ -242,7 +243,7 @@ export class TransportController {
   /**
    * Emit drained external effector invocations over the transport (2.4). Called
    * by the tick loop after `pendingEffectorInvocations` is spliced. The peer
-   * executes each and returns a result-ack (correlationId = decisionRecordId),
+   * executes each and returns a result-ack (correlationId = intentId),
    * which inbound dispatch routes to `confirmExecution`.
    */
   emitInvocations( instance: WillInstance, invocations: effectorInvocation[] ): void {
@@ -254,7 +255,7 @@ export class TransportController {
       this._emit( instance, {
         channel:       'effector_invocation',
         willId:        instance.config.id,
-        correlationId: invocation.decisionRecordId,
+        correlationId: invocation.intentId,
         seq:           this._nextSeq( instance.config.id ),
         wallTime:      wallClock(),
         invocation,
@@ -339,18 +340,41 @@ export class TransportController {
   private _dispatch( instance: WillInstance, env: InboundEnvelope, deps: InboundApplyDeps ): void {
     switch( env.channel ){
       case 'inbound_message': {
-        // Fire-and-forget: AuditionEngine.ingest() serializes per-entity
+        // Fire-and-forget: AuditionEngine.sense() serializes per-entity
         // internally; the tick must not block on the LLM reply.
+        // THE FIX THIS COMMENT USED TO PROMISE. It said `'unknown'` was right
+        // because the absence was STRUCTURAL — the envelope had no provenance
+        // field, so a remote host could not declare one however much it knew —
+        // and that all three dropped fields were one deliberate wire change
+        // rather than three patches. This is that change: the envelope now
+        // carries `provenance`, `direct` and `threadName`.
+        //
+        // With the field there, an omission stops being structural and becomes
+        // a caller's omission, which is exactly what `asProvenance()` is for at
+        // an untyped boundary (its own comment sends this case here).
+        //
+        // It is not cosmetic. `'unknown'` percepts are skipped by the rupture
+        // gate in `action.selector`, so a mind reached over a transport COULD
+        // NOT BE INTERRUPTED by anyone speaking to it, while the same words
+        // in-process could interrupt it — and the transport path is the default
+        // whenever one is bound. Two transports, two different minds.
+        const provenance = asProvenance( env.provenance )
         const input: SensoryInput = env.kind === 'voice'
-          ? { kind: 'voice', entityId: env.entityId, threadId: env.threadId, transcription: env.content }
+          ? { kind: 'voice', entityId: env.entityId, threadId: env.threadId, transcription: env.content, provenance }
           : {
-              kind:     'text',
-              entityId: env.entityId,
-              threadId: env.threadId,
-              content:  env.content,
+              kind:       'text',
+              entityId:   env.entityId,
+              threadId:   env.threadId,
+              content:    env.content,
+              provenance,
               ...( env.speakerName ? { speakerName: env.speakerName } : {} ),
+              // Omitted rather than defaulted, the same way the SDK door does
+              // it: an unknown room is not known to be public, and a room with
+              // no name stays unnamed rather than being labelled with its id.
+              ...( env.direct     !== undefined ? { direct:     env.direct     } : {} ),
+              ...( env.threadName ? { threadName: env.threadName } : {} ),
             }
-        void instance.cognition.auditionEngine.ingest( input )
+        void instance.cognition.auditionEngine.sense( input )
         break
       }
 

package/src/{channels → surface/channels}/discord.ts

@@ -1,10 +1,10 @@
 // ─────────────────────────────────────────────────────────────
-// src/channels/discord.ts — a Will present in a Discord server
+// src/surface/channels/discord.ts — a Will present in a Discord server
 // ─────────────────────────────────────────────────────────────
 //
 // The bridge relays both directions of the paradigm and nothing else:
 //
-//   inbound   guild/DM message → will.perceive({ from, speaker, text, thread })
+//   inbound   guild/DM message → will.sense({ from, speaker, text, thread })
 //             — every author is `discord:<userId>` (stable across guilds), the
 //             display name is *learned* by the mind, and each Discord channel
 //             is its own conversation thread.
@@ -22,9 +22,9 @@
 // `DiscordLikeClient` type keeps the dependency out of the type graph.
 // ─────────────────────────────────────────────────────────────
 
-import type { Will, WillMessage } from '#sdk/will'
-import { ChannelRoster } from '#channels/roster'
-import { chunkText, renderAttachments, isTextual, type ChannelBridge, type ChannelAttachment } from '#channels/types'
+import type { Will, WillMessage } from '#surface/sdk/will'
+import { ChannelRoster } from '#surface/channels/roster'
+import { chunkText, renderAttachments, isTextual, type ChannelBridge, type ChannelAttachment } from '#surface/channels/types'
 
 const DISCORD_MESSAGE_LIMIT = 2000
 
@@ -41,11 +41,52 @@ const DISCORD_CDN_HOSTS = new Set( [ 'cdn.discordapp.com', 'media.discordapp.net
  *  bounds what is *kept*, this bounds what is fetched at all. */
 const MAX_FETCH_BYTES = 256 * 1024
 
+/**
+ * How much of her own message to quote back when someone reacts to it.
+ *
+ * Enough to identify WHICH thing was agreed with — a bare "someone reacted 👍"
+ * closes the answered loop but tells the mind nothing about what was affirmed,
+ * and 0.9.0 established that an answer without its content is worse than none:
+ * it invites acting on an answer never seen.
+ */
+const REACTION_QUOTE_CHARS = 140
+
+/**
+ * What to call the room this was said in — `#general`, `#general › release-cut`,
+ * or `#general in Mindot` when the server is known.
+ *
+ * A LABEL, not an address. `discord:1531…` is how a message gets to the room;
+ * this is what a person calls it, and 0.9.0 established those are different
+ * facts. Without it a room had a dossier and no name, so it reached the mind as
+ * "something" — which is what the prompt says for a `thing` it cannot name — and
+ * a mind choosing where to speak was picking between two opaque numbers.
+ *
+ * Returns undefined for a DM: a private thread is not a place, it is the person,
+ * and the tracker deliberately gives it no dossier to name.
+ */
+function roomLabel( message: DiscordLikeMessage ): string | undefined {
+  if( !message.guildId ) return undefined
+  const own = message.channel?.name
+  if( !own ) return undefined
+  const parent = message.channel?.parent?.name
+  const room   = parent ? `#${ parent } › ${ own }` : `#${ own }`
+  const guild  = message.guild?.name
+  return guild ? `${ room } in ${ guild }` : room
+}
+
 // ── The slice of discord.js the bridge actually uses (structural) ───────────
 
 export interface DiscordLikeChannel {
   send( content: string ): Promise<unknown>
   sendTyping?(): Promise<unknown>
+  /** `general` for a text channel; absent on a DM, which has no name and is a person. */
+  name?: string | null
+  /** The thread's parent channel, so a thread reads as "#general › release-cut". */
+  parent?: { name?: string | null } | null
+  /** What the room is FOR, in the server's own words. Only read when asked. */
+  topic?: string | null
+  /** How many are in it — a count, never a roster. */
+  memberCount?: number
 }
 
 export interface DiscordLikeAttachment {
@@ -60,6 +101,8 @@ export interface DiscordLikeMessage {
   cleanContent?: string
   channelId: string
   guildId?: string | null
+  /** The server this was said in. Its NAME is what a person calls the place. */
+  guild?: { name?: string | null } | null
   author: { id: string; bot?: boolean; username?: string; displayName?: string }
   member?: { displayName?: string } | null
   mentions?: { has( userId: string ): boolean }
@@ -76,11 +119,38 @@ export interface DiscordLikeMessage {
   attachments?: ReadonlyMap<string, DiscordLikeAttachment> | Iterable<DiscordLikeAttachment>
 }
 
+/**
+ * A reaction, and the message it lands on.
+ *
+ * Both halves may be PARTIAL: Discord delivers a reaction on an uncached message
+ * with almost every field empty, which is the normal case for a message the bot
+ * sent before its current process started. `fetch()` fills it in, and the handler
+ * must call it rather than reading through the hole.
+ */
+export interface DiscordLikeReaction {
+  emoji:   { name?: string | null; id?: string | null }
+  message: DiscordLikeMessage & {
+    partial?: boolean
+    author?:  { id: string; bot?: boolean; username?: string; displayName?: string }
+    fetch?(): Promise<DiscordLikeReaction['message']>
+  }
+  partial?: boolean
+  fetch?(): Promise<DiscordLikeReaction>
+}
+
+export interface DiscordLikeReactor {
+  id:           string
+  bot?:         boolean
+  username?:    string
+  displayName?: string
+}
+
 export interface DiscordLikeClient {
   user: { id: string; setPresence?( p: unknown ): void } | null
   /** discord.js ≥14.22; polled so we needn't subscribe to the deprecated `ready`. */
   isReady?(): boolean
   on( event: 'messageCreate', fn: ( m: DiscordLikeMessage ) => void ): unknown
+  on( event: 'messageReactionAdd', fn: ( r: DiscordLikeReaction, u: DiscordLikeReactor ) => void ): unknown
   once( event: string, fn: () => void ): unknown
   login( token: string ): Promise<unknown>
   destroy(): Promise<unknown> | void
@@ -159,6 +229,70 @@ export async function connectDiscord( will: Will, opts: DiscordBridgeOptions ):
 
   // ── inbound: platform message → stimulus ──────────────────────────────────
   client.on('messageCreate', message => { void onMessage( message ) } )
+  client.on('messageReactionAdd', ( reaction, user ) => { void onReaction( reaction, user ) } )
+
+  /**
+   * Someone reacted to something the Will said.
+   *
+   * A reaction IS an answer, and until this existed the mind read it as silence.
+   * `conversation.received` is written only from a text percept, so a 👍 — the
+   * commonest acknowledgement on Discord — produced no record at all: the turn it
+   * answered stayed open, the reply window elapsed, and the mind concluded it had
+   * been ignored. That conclusion is not inert. It reaches reputation as
+   * reliability (−0.06 per unanswered turn) and goals as absence of progress, so
+   * answering her with an emoji actively taught her that person does not respond.
+   *
+   * Only reactions on the Will's OWN messages are perceived. A reaction between
+   * two other people in a busy channel is real social information, but it is not
+   * an answer to anything the mind said, and routing it here would swamp the
+   * conversation record it is meant to correct.
+   */
+  async function onReaction( reaction: DiscordLikeReaction, user: DiscordLikeReactor ): Promise<void> {
+    const self = client.user
+    if( !self || user.id === self.id || user.bot ) return
+
+    // Both may arrive partial — a reaction on a message this process never cached
+    // is the NORMAL case for anything said before the last restart, which is
+    // exactly the long-lived conversation this is here to keep honest.
+    const full = reaction.partial && reaction.fetch ? await reaction.fetch().catch( () => null ) : reaction
+    if( !full ) return
+    const msg = full.message.partial && full.message.fetch
+      ? await full.message.fetch().catch( () => null )
+      : full.message
+    if( !msg?.author ) return
+
+    if( msg.author.id !== self.id ) return                       // not ours — not an answer to us
+    const isDM = !msg.guildId
+    if( !isDM && allowed && !allowed.has( msg.channelId ) ) return
+
+    const emoji = full.emoji?.name ?? ( full.emoji?.id ? ':custom:' : '' )
+    if( !emoji ) return
+
+    const who  = user.displayName ?? user.username
+    const said = ( msg.cleanContent || msg.content || '').trim().slice( 0, REACTION_QUOTE_CHARS )
+
+    // Described, bracketed, first person — the same shape `renderAttachments` uses
+    // for a file, and for the same reason: this reached the mind through the
+    // conversation but nobody SAID it, and a percept that reads like speech invites
+    // the mind to answer words that were never spoken.
+    const text = said
+      ? `[${ who ?? 'someone' } reacted ${ emoji } to what I said: "${ said }"]`
+      : `[${ who ?? 'someone' } reacted ${ emoji } to something I said]`
+
+    await will.sense( {
+      text,
+      from:   `discord:${ user.id }`,
+      thread: `discord:${ msg.channelId }`,
+      direct: isDM,
+      // Exafferent, and the near-miss is worth naming: this is ABOUT something
+      // she did, but it is not her doing it. Somebody else reacted. Reafference
+      // is the mind sensing its OWN act's consequence, not the world's response
+      // to that act — a reply would fail the same test for the same reason.
+      provenance: 'exafferent',
+      ...( roomLabel( msg ) ? { threadName: roomLabel( msg ) } : {} ),
+      ...( who ? { speaker: who } : {} ),
+    } )
+  }
 
   async function onMessage( message: DiscordLikeMessage ): Promise<void> {
     const self = client.user
@@ -201,7 +335,7 @@ export async function connectDiscord( will: Will, opts: DiscordBridgeOptions ):
     )
     const text = [ said, shared ].filter( Boolean ).join('\n')
 
-    await will.perceive( {
+    await will.sense( {
       text,
       from:   entityId,
       thread: `discord:${ message.channelId }`,
@@ -210,6 +344,12 @@ export async function connectDiscord( will: Will, opts: DiscordBridgeOptions ):
       // the right or wrong place to say something, and the mind never saw it —
       // which is how a follow-up promised in a DM went out to #general.
       direct: isDM,
+      // Somebody spoke. The bridge already drops her own messages (`onMessage`
+      // returns early on `author.id === self.id`), so nothing reafferent can
+      // reach this line today — but that filter is a bridge-level deletion of
+      // a signal she is entitled to sense, not a reason for the field to lie.
+      provenance: 'exafferent',
+      ...( roomLabel( message ) ? { threadName: roomLabel( message ) } : {} ),
       ...( speaker ? { speaker } : {} ),
     } )
   }
@@ -262,6 +402,71 @@ export async function connectDiscord( will: Will, opts: DiscordBridgeOptions ):
     return ( await res.text() ).slice( 0, MAX_FETCH_BYTES )
   }
 
+  // ── the Will looks at something here, and Discord answers ─────────────────
+  //
+  // `inspect` is innate: every mind can look. What it finds depends on there
+  // being a world that can be asked, and this is Discord's answer.
+  //
+  // The answer is RETURNED AS AN OBSERVATION, and the engine turns it into a
+  // percept (SIGNAL_BOUNDARY P2). `description` says how the looking went;
+  // `observation` says what was found, and arrives at the mind as a reafferent
+  // percept tied to this act by `sourceIntentId` — so it can weigh the facts,
+  // disbelieve them, or decide they do not matter. An earlier cut wrote the
+  // answer straight into her dossier and beliefs, which is a mind being told
+  // what it knows rather than a mind finding out.
+  //
+  // This used to take TWO calls: return the ack, then separately `perceive()`
+  // the answer wrapped in a bracketed sentence — because an ack could not carry
+  // facts, and the sense door only accepted things somebody had said. The prose
+  // bracket was load-bearing: it was the only place the reafference lived where
+  // anything could read it. Both are gone.
+  will.effector('inspect', async ( _args, ctx ) => {
+    // The mind names a referent (`ke:1sqlkux`); we hold channel ids. The Will
+    // resolves the anchor to the addresses it was met at, and we take ours.
+    const address = ( ctx.targetAddresses ?? [] ).find( a => a.startsWith('discord:') )
+    if( !address ) return { success: false, description: 'Not something I can see on Discord.' }
+
+    const id = address.slice('discord:'.length )
+    const channel = await client.channels.fetch( id ).catch( () => null ) as DiscordLikeChannel | null
+    // A user id lands here too — a person is not a place, and Discord has nothing
+    // to say about them that watching them talk does not say better.
+    if( !channel?.name ) return { success: false, description: 'There is nothing here I can look up.' }
+
+    const facts: string[] = []
+    if( channel.topic )       facts.push(`it is for: ${ channel.topic }`)
+    if( channel.parent?.name ) facts.push(`it sits under #${ channel.parent.name }`)
+    if( typeof channel.memberCount === 'number')
+      // A COUNT, not a roster. Walking into a room you see that it is crowded long
+      // before you learn who anyone is; people become known by being met.
+      facts.push(`${ channel.memberCount } people are in it`)
+
+    if( facts.length === 0 )
+      return { success: false, description: `#${ channel.name } has nothing recorded about it.` }
+
+    const label = roomLabel( { channelId: id, guildId: 'g', channel } as DiscordLikeMessage ) ?? `#${ channel.name }`
+
+    return {
+      success:     true,
+      description: `Looked into ${ label }.`,
+      // The room as Discord has it, in the shape Discord has it. Not flattened
+      // into a sentence for the mind's benefit — a host that reshapes its own
+      // data is deciding what the mind may notice about it, and `observation`
+      // takes whatever shape the answer already had.
+      //
+      // `summary` is the one concession: it is what the executive prompt renders,
+      // so the host says it in words rather than leaving the mind to read JSON.
+      // Everything beside it stays available.
+      observation: {
+        summary:  `I looked into ${ label }: ${ facts.join('; ') }.`,
+        room:     label,
+        address,
+        ...( channel.topic          ? { topic: channel.topic } : {} ),
+        ...( channel.parent?.name   ? { parent: `#${ channel.parent.name }` } : {} ),
+        ...( typeof channel.memberCount === 'number' ? { memberCount: channel.memberCount } : {} ),
+      },
+    }
+  } )
+
   // ── outbound: projected utterance → the addressee ─────────────────────────
   // The facade has no off(); the bridge gates its handler on `closed` instead.
   let closed = false
@@ -352,8 +557,20 @@ async function createDiscordClient(): Promise<DiscordLikeClient> {
       GatewayIntentBits.GuildMessages,
       GatewayIntentBits.MessageContent,
       GatewayIntentBits.DirectMessages,
+      // Neither is privileged, so this costs nothing to ask for — and without
+      // them an emoji answer never arrives and reads as being ignored.
+      GatewayIntentBits.GuildMessageReactions,
+      GatewayIntentBits.DirectMessageReactions,
+    ],
+    partials: [
+      Partials.Channel,     // DMs arrive on uncached channels
+      // A reaction on a message this process did not cache — i.e. anything said
+      // before the last restart — is delivered partial, and without these the
+      // event is dropped before the handler sees it. That is precisely the
+      // long-running conversation the answered loop exists for.
+      Partials.Message,
+      Partials.Reaction,
     ],
-    partials: [ Partials.Channel ],   // DMs arrive on uncached channels
   } ) as unknown as DiscordLikeClient
 }
 

package/src/{channels → surface/channels}/roster.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// src/channels/roster.ts — who the Will knows on a platform, and where
+// src/surface/channels/roster.ts — who the Will knows on a platform, and where
 // ─────────────────────────────────────────────────────────────
 //
 // The mind knows *entities*; a platform knows user ids and channels. The roster

package/src/{channels → surface/channels}/types.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// src/channels/types.ts — the channel-bridge contract
+// src/surface/channels/types.ts — the channel-bridge contract
 // ─────────────────────────────────────────────────────────────
 //
 // A channel bridge puts a Will *in a place where people already are* (Discord,

package/src/{channels → surface/channels}/whatsapp.ts

@@ -1,10 +1,10 @@
 // ─────────────────────────────────────────────────────────────
-// src/channels/whatsapp.ts — a Will present on WhatsApp
+// src/surface/channels/whatsapp.ts — a Will present on WhatsApp
 // ─────────────────────────────────────────────────────────────
 //
 // Same paradigm as the Discord bridge, different room:
 //
-//   inbound   DM / group message → will.perceive({ from, speaker, text, thread })
+//   inbound   DM / group message → will.sense({ from, speaker, text, thread })
 //             — every author is `whatsapp:<number>` (stable across chats), the
 //             push name is *learned* by the mind, and each chat (DM or group)
 //             is its own conversation thread.
@@ -25,9 +25,9 @@
 // `WaLikeSocket` type keeps the dependency out of the type graph.
 // ─────────────────────────────────────────────────────────────
 
-import type { Will, WillMessage } from '#sdk/will'
-import { ChannelRoster } from '#channels/roster'
-import { chunkText, type ChannelBridge } from '#channels/types'
+import type { Will, WillMessage } from '#surface/sdk/will'
+import { ChannelRoster } from '#surface/channels/roster'
+import { chunkText, type ChannelBridge } from '#surface/channels/types'
 
 /** WhatsApp's hard per-message cap. */
 const WHATSAPP_MESSAGE_LIMIT = 65_536
@@ -162,7 +162,10 @@ export async function connectWhatsApp( will: Will, opts: WhatsAppBridgeOptions =
     const text = textOf( m )
     if( !text.trim() ) return
 
-    await will.perceive( {
+    await will.sense( {
+      // Somebody messaged her. Baileys filters `fromMe` upstream, so as with
+      // Discord nothing reafferent reaches this bridge today.
+      provenance: 'exafferent',
       text,
       from:   entityId,
       thread: `whatsapp:${ jid }`,

package/src/{cli.ts → surface/cli.ts}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // ─────────────────────────────────────────────────────────────
-// src/cli.ts — the `will` command: host a persistent mind
+// src/surface/cli.ts — the `will` command: host a persistent mind
 // ─────────────────────────────────────────────────────────────
 //
 //   will mcp       host over MCP stdio (Claude Desktop / Claude Code / IDEs)
@@ -24,11 +24,11 @@
 // ─────────────────────────────────────────────────────────────
 
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { routeLogsToStderr, bootWillFromEnv } from '#root/host/boot'
-import { buildWillMcpServer } from '#root/mcp/server'
-import { buildWillHttpServer } from '#root/serve/server'
-import { connectDiscord, parseChannels, parseMentionOnly } from '#channels/discord'
-import { connectWhatsApp } from '#channels/whatsapp'
+import { routeLogsToStderr, bootWillFromEnv } from '#surface/host/boot'
+import { buildWillMcpServer } from '#surface/mcp/server'
+import { buildWillHttpServer } from '#surface/serve/server'
+import { connectDiscord, parseChannels, parseMentionOnly } from '#surface/channels/discord'
+import { connectWhatsApp } from '#surface/channels/whatsapp'
 
 // stdout is the MCP protocol channel under `will mcp` — route logs FIRST.
 routeLogsToStderr()

package/src/{host → surface/host}/boot.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// src/host/boot.ts — shared boot/shutdown for the `will` CLI hosts
+// src/surface/host/boot.ts — shared boot/shutdown for the `will` CLI hosts
 // ─────────────────────────────────────────────────────────────
 //
 // Both hosts (`will mcp`, `will serve`) raise the same mind the same way:
@@ -27,9 +27,9 @@
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 import { setLogger } from '#core/logger'
-import { Will, detectProvider, type CreateWillOptions } from '#sdk/will'
+import { Will, detectProvider, type CreateWillOptions } from '#surface/sdk/will'
 import type { PMASnapshot } from '#pma/index'
-import { connectMcpEffectors, type McpToolsSource } from '#root/mcp/effectors'
+import { connectMcpEffectors, type McpToolsSource } from '#surface/mcp/effectors'
 import { anthropicWireHeaders, defaultBaseFor, knownWireFor, providerKeyFromEnv, PROVIDER_KEY_ENV, type LLMProvider, type LLMWire } from '#llm/index'
 
 /**

package/src/{host → surface/host}/utterances.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// src/host/utterances.ts — a host-side tap on a Will's speech
+// src/surface/host/utterances.ts — a host-side tap on a Will's speech
 // ─────────────────────────────────────────────────────────────
 //
 // Hosts that expose a Will over a request/response protocol (MCP tools, HTTP
@@ -10,7 +10,7 @@
 // first, else wait, else report silence (null — a choice, never an error).
 // ─────────────────────────────────────────────────────────────
 
-import type { Will, WillMessage } from '#sdk/will'
+import type { Will, WillMessage } from '#surface/sdk/will'
 
 const BUFFER_CAP = 50