@mindot/will 0.4.0 → 0.6.0

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. */