@mindot/will 0.5.0 → 0.6.0

package/src/stem/mind.ts

@@ -409,10 +409,10 @@ export function _resolveVectorMemory(
   const mockMode = process.env.WILL_VECTOR_MEMORY === 'mock'
   const rawModel = embeddingModel
     ?? process.env.WILL_EMBEDDING_MODEL
-    ?? ( process.env.WILL_EMBEDDING_API_KEY ? 'text-embedding-3-small' : 'none' )
+    ?? ( process.env.WILL_EMBEDDING_API_KEY ? 'text-embedding-3-small' : 'none')
 
   // Explicitly disabled — the documented "none" sentinel or recall turned off.
-  if( !mockMode && ( rawModel === 'none' || process.env.WILL_SEMANTIC_RECALL === 'false' ) )
+  if( !mockMode && ( rawModel === 'none' || process.env.WILL_SEMANTIC_RECALL === 'false') )
     return { embedder: null, vectorMemory: null }
 
   // testMode promises a deterministic, zero-key, offline mind — but a dev .env
@@ -581,9 +581,9 @@ export function assembleMind( willId: string, config: WillConfig ): MindAssembly
     profileContext: profile?.context,
   })
   if( !idGuard.ok )
-    throw new Error( `Invalid Will identity for "${willId}": ${ idGuard.errors.join( '; ' ) }` )
+    throw new Error(`Invalid Will identity for "${willId}": ${ idGuard.errors.join('; ') }`)
   for( const w of idGuard.warnings )
-    logger.warn( `[identity-guard] ${willId}: ${w}` )
+    logger.warn(`[identity-guard] ${willId}: ${w}`)
   config = { ...config, identity: idGuard.sanitized.identity }
 
   // ── Construct ────────────────────────────────────────────
@@ -602,8 +602,8 @@ export function assembleMind( willId: string, config: WillConfig ): MindAssembly
   // sessionLogger/grants); tests/unit/assembly.order.test.ts pins that set per
   // tier, so a NEW unwired attachment fails loudly in CI, not here.
   for( const rec of auditAssemblyWiring( simulation.orchestrator.engines ) )
-    if( rec.status === 'unwired' )
-      logger.debug( `[assembly] ${willId}: ${rec.engine}.${rec.method} unwired at assembly (anatomy=${anatomy})` )
+    if( rec.status === 'unwired')
+      logger.debug(`[assembly] ${willId}: ${rec.engine}.${rec.method} unwired at assembly (anatomy=${anatomy})`)
 
   // ── Seed readable simulation state ───────────────────────
   // Identity, optional initial goals, and the engine-config mirror.
@@ -772,7 +772,7 @@ function _constructCognition(
   // ── Planning Engine ──────────────────────────────────────
   const planningEngine = new PlanningEngine()
   planningEngine.attachGoalManager( goalManager )
-  if( anatomy !== 'reflex' ) planningEngine.attachExecutiveEngine( executiveEngine )
+  if( anatomy !== 'reflex') planningEngine.attachExecutiveEngine( executiveEngine )
   executiveEngine.attachPlanningEngine( planningEngine )
 
   // ── Executive ────────────────────────────────────────────
@@ -791,7 +791,7 @@ function _constructCognition(
   autobiographicalNarrator.attachEpisodicConsolidator( episodicConsolidator )
   autobiographicalNarrator.attachSemanticIntegrator( semanticIntegrator )
   // Satellites harvest the executive's own output — attach wherever it runs.
-  if( anatomy !== 'reflex' ){
+  if( anatomy !== 'reflex'){
     autobiographicalNarrator.attachExecutiveEngine( executiveEngine )
     introspectionEngine.attachExecutiveEngine( executiveEngine )
   }
@@ -807,7 +807,7 @@ function _constructCognition(
   empathySimulator.attachTheoryOfMind( theoryOfMind )
 
   // ── Context compaction components (mind anatomy only) ──
-  if( anatomy !== 'reflex' ){
+  if( anatomy !== 'reflex'){
     const summarizer = new ExecutiveSummarizer({
       summaryInterval:   parseInt( process.env.WILL_SUMMARY_INTERVAL   ?? '10'),
       bufferSize:        parseInt( process.env.WILL_SUMMARY_BUFFER_SIZE ?? '12'),
@@ -845,7 +845,7 @@ function _constructCognition(
   const olfactionEngine       = new OlfactionEngine()
   const gustationEngine       = new GustationEngine()
 
-  if( anatomy !== 'reflex' )
+  if( anatomy !== 'reflex')
     auditionEngine.attachExecutiveEngine( executiveEngine )
 
   // §5.4 — cold-spawn digest hydration: on the first turn for an entity, seed an
@@ -906,7 +906,7 @@ function _constructCognition(
   // winner (graceful System-1 degradation).
   const deliberationEngine = new DeliberationEngine()
   deliberationEngine.setWillName( config.name )
-  if( anatomy !== 'reflex' )
+  if( anatomy !== 'reflex')
     deliberationEngine.attachExecutive( executiveEngine )
 
   // ── Build Cognition ──────────────────────────────────────
@@ -1108,7 +1108,7 @@ function _seedIdentity(
   // to infer its identity from context. config.name is the canonical source of truth.
   const nameAlreadyInPrompt = personaText.toLowerCase().includes( config.name.toLowerCase() )
   const namePrefix = nameAlreadyInPrompt ? '' : `I am ${config.name}.`
-  const fullPersonaText = [ namePrefix, personaText ].filter( Boolean ).join( ' ' )
+  const fullPersonaText = [ namePrefix, personaText ].filter( Boolean ).join(' ')
 
   const prompt = [
     WILL_CORE_PREAMBLE,

package/src/stem/tracts/biography.writer.ts

@@ -38,15 +38,15 @@ export class BiographyWriter {
     if( !fileLoggingEnabled() ) return
 
     const dataDir = process.env[ 'WILL_DATA_DIR' ] ?? './data'
-    const dir     = join( dataDir, 'wills', willId, 'profiles' )
+    const dir     = join( dataDir, 'wills', willId, 'profiles')
     try {
       if( !this._ensuredDirs.has( dir ) ){
         mkdirSync( dir, { recursive: true } )
         this._ensuredDirs.add( dir )
       }
-      appendFileSync( join( dir, file ), JSON.stringify( record ) + '\n', 'utf8' )
+      appendFileSync( join( dir, file ), JSON.stringify( record ) + '\n', 'utf8')
     } catch( err ){
-      logger.error( `[biography] ${file} write failed:`, err )
+      logger.error(`[biography] ${file} write failed:`, err )
     }
   }
   /**

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

@@ -91,11 +91,11 @@ export class effectorController {
     const tick = instance.tickCount
 
     const intent = instance.simulation.stateManager.snapshot().entities.get( invocationId )
-    if( !intent || intent.type !== 'agency.intent' ){
+    if( !intent || intent.type !== 'agency.intent'){
       // No awaiting intent for this id. Expected when the executor's 15-tick await
       // timeout already abandoned it (writing a failed outcome + advancing any plan)
       // before the host's late ack arrived, or the id is unknown. Drop the straggler.
-      logger.warn( `[effector] confirmExecution: no awaiting agency.intent "${invocationId}" (timed out / already reconciled?) — ignored` )
+      logger.warn(`[effector] confirmExecution: no awaiting agency.intent "${invocationId}" (timed out / already reconciled?) — ignored`)
       return
     }
 
@@ -122,7 +122,7 @@ export class effectorController {
         if( typeof v === 'number' && Number.isFinite( v ) )
           instance.simulation.stateManager.setMetric( k, v )
         else
-          logger.warn( `[effector] confirmExecution: dropped non-finite metric "${k}"=${String( v )} from host ack (${schema})` )
+          logger.warn(`[effector] confirmExecution: dropped non-finite metric "${k}"=${String( v )} from host ack (${schema})`)
       }
 
     instance.sessionLogger?.write({
@@ -135,7 +135,7 @@ export class effectorController {
       confirmedExternally: true,
     } as never)
 
-    logger.info( `[effector] ✓ reconciled ${result.success ? 'success' : 'failure'}: intent "${invocationId}" (${schema})` )
+    logger.info(`[effector] ✓ reconciled ${result.success ? 'success' : 'failure'}: intent "${invocationId}" (${schema})`)
   }
 }
 

package/src/stem/tracts/health.reporter.ts

@@ -87,7 +87,7 @@ export class HealthReporter {
     for( const entity of instance.simulation.stateManager.getEntitiesByType('goal') ){
       totalGoals++
       const s = entity.metadata?.status
-      if( s === 'active' || s === 'in_progress' ) activeGoals++
+      if( s === 'active' || s === 'in_progress') activeGoals++
     }
 
     const goalScore = totalGoals === 0

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

@@ -104,6 +104,10 @@ export class OutboxController {
           : `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',
         messageId,
       },
     })

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

@@ -53,7 +53,7 @@ export class OutboxWriter {
     this._sessionLogger = logger
   }
 
-  private _genId( suffix = '' ): string {
+  private _genId( suffix = ''): string {
     return `outbox-${ this._willId }-${ ++this._seq }${ suffix }`
   }
 
@@ -61,7 +61,7 @@ export class OutboxWriter {
    * Push one canonical outbox row and return its generated id. The single point
    * where the row shape is materialized — all producers funnel through here.
    */
-  enqueue( row: OutboxRow, idSuffix = '' ): string {
+  enqueue( row: OutboxRow, idSuffix = ''): string {
     const id = this._genId( idSuffix )
     this._outbox.push({
       id,
@@ -105,7 +105,7 @@ export class OutboxWriter {
 
     const ids: string[] = []
     bubbles.forEach( ( bubble, i ) => {
-      if( !pushToOutbox ){ ids.push( this._genId( `-${ i }` ) ); return }
+      if( !pushToOutbox ){ ids.push( this._genId(`-${ i }`) ); return }
       logger.info(`[outbox-writer] reply → ${ entityId } bubble[${ i }] "${ bubble.slice( 0, 80 ) }"`)
       ids.push( this.enqueue({
         targetEntityId:   entityId,
@@ -113,7 +113,7 @@ export class OutboxWriter {
         content:          bubble,
         effectorName:      'text',
         threadId,
-      }, `-${ i }` ) )
+      }, `-${ i }`) )
     } )
 
     this._sessionLogger?.write({

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

@@ -29,7 +29,7 @@ export class PMAController {
    * with existing beliefs may cause unintended merges.
    */
   load( id: string, instance: WillInstance, pma: PMASnapshot ): void {
-    if( instance.status === 'active' )
+    if( instance.status === 'active')
       throw new Error(`Cannot load PMA into an active Will (${id}). Pause first.`)
 
     // Re-validate the artifact's persona at the load boundary (Phase 2): a stored

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

@@ -44,7 +44,7 @@ export class ReplayController {
     // Pre-create the replay dir so flush() can persist segments incrementally
     // (stop() saves the consolidated file into the same dir).
     const dataDir = process.env[ 'WILL_DATA_DIR' ] ?? './data'
-    const dir     = join( dataDir, 'wills', id, 'replays' )
+    const dir     = join( dataDir, 'wills', id, 'replays')
     mkdirSync( dir, { recursive: true } )
 
     const recorder = this._replayManager.createRecorder( id, runId, undefined, {
@@ -74,10 +74,10 @@ export class ReplayController {
     this._activeRecorders.delete( id )
 
     const dataDir = process.env[ 'WILL_DATA_DIR' ] ?? './data'
-    const dir     = join( dataDir, 'wills', id, 'replays' )
+    const dir     = join( dataDir, 'wills', id, 'replays')
     mkdirSync( dir, { recursive: true } )
 
-    const path = join( dir, `${active.runId}.json` )
+    const path = join( dir, `${active.runId}.json`)
     await active.recorder.save( path )
 
     const meta = active.recorder.getMetadata()
@@ -97,11 +97,11 @@ export class ReplayController {
     if( cached ) return cached
 
     const dataDir = process.env[ 'WILL_DATA_DIR' ] ?? './data'
-    const path    = join( dataDir, 'wills', id, 'replays', `${runId}.json` )
+    const path    = join( dataDir, 'wills', id, 'replays', `${runId}.json`)
     if( !existsSync( path ) ) return null
 
     try {
-      const meta = ( JSON.parse( readFileSync( path, 'utf8' ) ) as { metadata: ReplayMetadata } ).metadata
+      const meta = ( JSON.parse( readFileSync( path, 'utf8') ) as { metadata: ReplayMetadata } ).metadata
       this._completedReplays.set( key, meta )
       this._replayPaths.set( key, path )
       return meta
@@ -121,7 +121,7 @@ export class ReplayController {
       if( key.startsWith( prefix ) ) results.push( meta )
 
     const dataDir = process.env[ 'WILL_DATA_DIR' ] ?? './data'
-    const dir     = join( dataDir, 'wills', id, 'replays' )
+    const dir     = join( dataDir, 'wills', id, 'replays')
 
     if( existsSync( dir ) ){
       const inMem = new Set(
@@ -137,7 +137,7 @@ export class ReplayController {
         if( inMem.has( runId ) ) continue
         try {
           const path   = join( dir, file )
-          const meta   = ( JSON.parse( readFileSync( path, 'utf8' ) ) as { metadata: ReplayMetadata } ).metadata
+          const meta   = ( JSON.parse( readFileSync( path, 'utf8') ) as { metadata: ReplayMetadata } ).metadata
           const key    = `${id}:${runId}`
           this._completedReplays.set( key, meta )
           this._replayPaths.set( key, path )
@@ -164,14 +164,14 @@ export class ReplayController {
    * process (e.g. after a server restart).
    */
   private _resolvePath( id: string, runId: string ): string | undefined {
-    const cached = this._replayPaths.get( `${id}:${runId}` )
+    const cached = this._replayPaths.get(`${id}:${runId}`)
     if( cached ) return cached
 
     const dataDir = process.env[ 'WILL_DATA_DIR' ] ?? './data'
-    const path    = join( dataDir, 'wills', id, 'replays', `${runId}.json` )
+    const path    = join( dataDir, 'wills', id, 'replays', `${runId}.json`)
     if( !existsSync( path ) ) return undefined
 
-    this._replayPaths.set( `${id}:${runId}`, path )
+    this._replayPaths.set(`${id}:${runId}`, path )
     return path
   }
 }

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

@@ -52,7 +52,7 @@ export class SensoryController {
       gustation:       cog.gustationEngine,
     }
     const engine = engineMap[ domain ]
-    if( !engine ) throw Object.assign( new Error( `Unknown sense domain: ${domain}` ), { code: 400 } )
+    if( !engine ) throw Object.assign( new Error(`Unknown sense domain: ${domain}`), { code: 400 } )
     await engine.ingest( input )
   }
 
@@ -135,7 +135,7 @@ export class SensoryController {
   private _ensureChunkFanout( instance: WillInstance ): void {
     if( this._chunkWired.has( instance ) ) return
     const audition = instance.cognition.auditionEngine
-    if( typeof ( audition as { addChunkCallback?: unknown } ).addChunkCallback !== 'function' ) return
+    if( typeof ( audition as { addChunkCallback?: unknown } ).addChunkCallback !== 'function') return
 
     this._chunkWired.add( instance )
     audition.addChunkCallback( ( entityId: string, _threadId: string, chunk: string ) => {

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

@@ -97,7 +97,7 @@ export class SessionLogger {
   private          _count    = 0
 
   constructor( willId: string, dataDir: string = './data', opts: SessionLoggerOptions = {} ) {
-    const ts  = new Date().toISOString().replace( /[:.]/g, '-' ).slice( 0, 19 )
+    const ts  = new Date().toISOString().replace( /[:.]/g, '-').slice( 0, 19 )
     const rnd = Math.random().toString( 36 ).slice( 2, 8 )
     this.sessionId = `${ts}-${rnd}`
 
@@ -105,9 +105,9 @@ export class SessionLogger {
 
     const fileLogging = opts.fileLogging ?? false
     if( fileLogging ){
-      const dir = join( opts.dataDir ?? dataDir, 'wills', willId, 'sessions' )
+      const dir = join( opts.dataDir ?? dataDir, 'wills', willId, 'sessions')
       mkdirSync( dir, { recursive: true } )
-      this.filePath = join( dir, `${this.sessionId}.jsonl` )
+      this.filePath = join( dir, `${this.sessionId}.jsonl`)
       this._stream  = createWriteStream( this.filePath, { flags: 'a' } )
     } else {
       this.filePath = ''
@@ -133,7 +133,7 @@ export class SessionLogger {
 
     // File is a dev-only mirror.
     if( this._stream ){
-      try { this._stream.write( JSON.stringify( record ) + '\n' ) }
+      try { this._stream.write( JSON.stringify( record ) + '\n') }
       catch { /* never block the tick loop on a log failure */ }
     }
 

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

@@ -91,7 +91,7 @@ export class SocketIoTransport implements ExternalTransport {
       const timer = setTimeout( () => done({ acked: false, via: 'timeout' }), timeoutMs )
 
       try {
-        socket.emit( 'envelope', stamped, ( response: unknown ) => done({ acked: true, via: 'callback', payload: response }) )
+        socket.emit('envelope', stamped, ( response: unknown ) => done({ acked: true, via: 'callback', payload: response }) )
       }
       catch( err ){
         logger.warn(`[socketio-transport] emit failed: ${( err as Error ).message}`)
@@ -159,20 +159,20 @@ export class SocketIoTransport implements ExternalTransport {
 
   /** Attach socket.io event handlers that feed the inbound + status streams. */
   private _wire( socket: SocketLike ): void {
-    socket.on( 'connect',    () => this._notifyStatus( 'connected' ) )
-    socket.on( 'disconnect', () => this._notifyStatus( 'disconnected' ) )
-    socket.on( 'reconnect_attempt', () => this._notifyStatus( 'reconnecting' ) )
+    socket.on('connect',    () => this._notifyStatus('connected') )
+    socket.on('disconnect', () => this._notifyStatus('disconnected') )
+    socket.on('reconnect_attempt', () => this._notifyStatus('reconnecting') )
 
     // Primary inbound channel — already-typed envelopes from the peer.
-    socket.on( 'envelope', ( env: InboundEnvelope ) => this._emitInbound( env ) )
+    socket.on('envelope', ( env: InboundEnvelope ) => this._emitInbound( env ) )
 
     // Discrete ack events (Section 2): in case the peer emits acks independently
     // rather than via the emit() callback. Synthesized into ack envelopes; the
     // AckReconciler (Section 3) dedups against the callback path by correlationId.
-    socket.on( 'message.delivered', ( m: { correlationId: string; delivered?: boolean } ) =>
+    socket.on('message.delivered', ( m: { correlationId: string; delivered?: boolean } ) =>
       this._emitInbound( this._deliveryAck( m.correlationId, m.delivered ?? true ) ) )
 
-    socket.on( 'effector.invoked.ack', ( m: { correlationId: string; result: AckEnvelope['result'] } ) =>
+    socket.on('effector.invoked.ack', ( m: { correlationId: string; result: AckEnvelope['result'] } ) =>
       this._emitInbound( this._resultAck( m.correlationId, m.result ) ) )
   }
 

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

@@ -39,7 +39,7 @@ export class StreamTransport implements ExternalTransport {
   private readonly _inboundHandlers = new Set<( env: InboundEnvelope ) => void>()
   private readonly _statusHandlers  = new Set<( s: TransportStatus ) => void>()
 
-  constructor( willId: string = 'stream' ){
+  constructor( willId: string = 'stream'){
     this.willId = willId
   }
 
@@ -71,7 +71,7 @@ export class StreamTransport implements ExternalTransport {
    * `'reply'`) or `'*'` for all. Returns an unsubscribe function.
    */
   on( channel: StreamChannel, listener: OutboundListener ): () => void {
-    if( channel === '*' ) return this.subscribe( listener )
+    if( channel === '*') return this.subscribe( listener )
     let set = this._outboundByCh.get( channel )
     if( !set ){ set = new Set(); this._outboundByCh.set( channel, set ) }
     set.add( listener )

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

@@ -88,12 +88,12 @@ export class TransportController {
    * the SAME path discrete ack events take — so applyInbound() reconciles both
    * idempotently. 'none' = fire-and-forget (chunks, replies: no outbox entry to mark).
    */
-  private _emit( instance: WillInstance, env: OutboundEnvelope, reconcileAs: 'delivery' | 'result' | 'none' ): void {
+  private _emit( instance: WillInstance, env: OutboundEnvelope, reconcileAs: 'delivery' | 'result' | 'none'): void {
     const transport = instance.transport
     if( !transport ) return
 
     // Buffer state-affecting outbound until acked, so a reconnect can re-emit it.
-    if( reconcileAs !== 'none' ){
+    if( reconcileAs !== 'none'){
       const pending = this._pendingFor( instance.config.id )
       pending.set( env.correlationId, env )
       // Bound the buffer — drop the oldest un-acked envelope past the cap (FIFO).
@@ -105,7 +105,7 @@ export class TransportController {
     }
 
     const pending = transport.emit( env )
-    if( reconcileAs === 'none' ){ void pending; return }
+    if( reconcileAs === 'none'){ void pending; return }
 
     void pending.then( ack => {
       if( !ack.acked ) return
@@ -120,9 +120,9 @@ export class TransportController {
 
   /** Coerce an emit-callback ack payload into a confirmExecution result, or null. */
   private _asResult( payload: unknown ): { success: boolean; description: string; metrics?: Record<string, number> } | null {
-    if( payload && typeof payload === 'object' && typeof ( payload as { success?: unknown } ).success === 'boolean' ){
+    if( payload && typeof payload === 'object' && typeof ( payload as { success?: unknown } ).success === 'boolean'){
       const p = payload as { success: boolean; description?: unknown; metrics?: Record<string, number> }
-      return { success: p.success, description: String( p.description ?? '' ), ...( p.metrics ? { metrics: p.metrics } : {} ) }
+      return { success: p.success, description: String( p.description ?? ''), ...( p.metrics ? { metrics: p.metrics } : {} ) }
     }
     return null
   }
@@ -142,7 +142,7 @@ export class TransportController {
       seq,
       wallTime:      wallClock(),
       entry,
-    }, 'none' )
+    }, 'none')
   }
 
   /**
@@ -159,7 +159,7 @@ export class TransportController {
       seq,
       wallTime:      wallClock(),
       report,
-    }, 'none' )
+    }, 'none')
   }
 
   /**
@@ -185,7 +185,7 @@ export class TransportController {
         entityId,
         threadId,
         bubbles,
-      }, 'none' )
+      }, 'none')
     } )
 
     // Outbound chunk fast-path (2.2): stream each filtered reply token off-tick.
@@ -200,13 +200,13 @@ export class TransportController {
         entityId,
         threadId,
         content,
-      }, 'none' )
+      }, 'none')
     } )
     this._chunkUnsub.set( instance.config.id, chunkUnsub )
 
     // Outbound activity projection (2.5): forward all plan/activity events
     // ('*' wildcard = no entity filter). Observability only — fire-and-forget.
-    const activityUnsub = instance.cognition.planningEngine.addActivityListener( '*', event => {
+    const activityUnsub = instance.cognition.planningEngine.addActivityListener('*', event => {
       this._emit( instance, {
         channel:       'activity',
         willId:        instance.config.id,
@@ -216,13 +216,13 @@ export class TransportController {
         entityId:      event.requestingEntityId ?? '',
         eventType:     event.type,
         payload:       { ...event },
-      }, 'none' )
+      }, 'none')
     } )
     this._activityUnsub.set( instance.config.id, activityUnsub )
 
     // Reconnect: re-emit un-acked messages/invocations when the link returns.
     const statusUnsub = transport.onStatus( status => {
-      if( status === 'connected' ) this._reemitPending( instance )
+      if( status === 'connected') this._reemitPending( instance )
     } )
     this._statusUnsub.set( instance.config.id, statusUnsub )
 
@@ -236,7 +236,7 @@ export class TransportController {
 
     logger.info(`[transport] reconnect — re-emitting ${pending.size} un-acked envelope(s) for ${instance.config.id}`)
     for( const env of [ ...pending.values() ] )
-      this._emit( instance, env, env.channel === 'effector_invocation' ? 'result' : 'delivery' )
+      this._emit( instance, env, env.channel === 'effector_invocation' ? 'result' : 'delivery')
   }
 
   /**
@@ -258,7 +258,7 @@ export class TransportController {
         seq:           this._nextSeq( instance.config.id ),
         wallTime:      wallClock(),
         invocation,
-      }, 'result' )
+      }, 'result')
   }
 
   /**
@@ -279,7 +279,7 @@ export class TransportController {
         seq:           this._nextSeq( instance.config.id ),
         wallTime:      wallClock(),
         message,
-      }, 'delivery' )
+      }, 'delivery')
   }
 
   /** Tear down the transport and discard any un-applied inbound. */