@mindot/will 0.8.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/outbox.writer.ts

@@ -21,6 +21,19 @@ import { logger } from '#core/logger'
 import type { OutboxMessage } from '#types'
 import type { SessionLogger } from './session.logger'
 
+/**
+ * Referent → a deliverable address, and the room to use when none was chosen.
+ *
+ * Returns null when the referent is already an address (nothing to translate) or
+ * when the mind holds no route at all — in which case the row goes out as-is and
+ * the bridge's own roster fallback still applies, so a message is never silently
+ * dropped for want of a handle.
+ */
+export type OutboxRouting = (
+  targetEntityId: string,
+  chosenThread:   string | undefined,
+) => { targetEntityId: string; threadId?: string } | null
+
 /** The caller-supplied fields of an outbox row; the writer stamps id + defaults. */
 export interface OutboxRow {
   targetEntityId:    string
@@ -43,6 +56,7 @@ export class OutboxWriter {
    * which made the embedded ids in `conversation.sent` diverge every run).
    */
   private _seq = 0
+  private _routing: OutboxRouting | null = null
 
   constructor( opts: { outbox?: OutboxMessage[]; willId?: string } = {} ){
     this._outbox = opts.outbox ?? []
@@ -53,6 +67,21 @@ export class OutboxWriter {
     this._sessionLogger = logger
   }
 
+  /**
+   * Turn a referent into somewhere the world can actually be spoken to.
+   *
+   * Injected rather than read here, because this writer is deliberately dumb —
+   * it holds no state and must stay replay-safe. Assembly closes over the state
+   * manager (the same shape as `attachMemorySink`).
+   *
+   * This is the ONE seam both send paths cross: ProactiveCommunicator's
+   * `enqueue()` and AuditionEngine's `enqueueReply()`. Translating anywhere else
+   * would mean doing it twice and getting it wrong once.
+   */
+  attachRouting( resolve: OutboxRouting | null ): void {
+    this._routing = resolve
+  }
+
   private _genId( suffix = ''): string {
     return `outbox-${ this._willId }-${ ++this._seq }${ suffix }`
   }
@@ -63,15 +92,24 @@ export class OutboxWriter {
    */
   enqueue( row: OutboxRow, idSuffix = ''): string {
     const id = this._genId( idSuffix )
+    // A `ke:` anchor is who, never where. Resolve it to an address the bridge can
+    // deliver to and a room to say it in — and where a room was already chosen
+    // (a reply answers into the thread it was asked in), that choice WINS. The
+    // mind picking a room is a decision; this is only the fallback for when it
+    // made none, and the alternative to the fallback is dropping the message.
+    const routed = this._routing?.( row.targetEntityId, row.threadId ) ?? null
+    const target = routed?.targetEntityId ?? row.targetEntityId
+    const thread = row.threadId ?? routed?.threadId
+
     this._outbox.push({
       id,
-      targetEntityId:   row.targetEntityId,
+      targetEntityId:   target,
       ...( row.targetEntityName !== undefined ? { targetEntityName: row.targetEntityName } : {} ),
       content:          row.content,
       effectorName:      row.effectorName,
       ...( row.gestureType      ? { gestureType:      row.gestureType }      : {} ),
       ...( row.replyToMessageId ? { replyToMessageId: row.replyToMessageId } : {} ),
-      ...( row.threadId         ? { threadId:         row.threadId }         : {} ),
+      ...( thread               ? { threadId:         thread }               : {} ),
       deliveryStatus:   'pending',
       createdAtTick:    0,
       createdAt:        Date.now(),

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
       }