@mindot/will 0.4.0 → 0.6.0

package/src/cognition/agency/revocation.ts

@@ -0,0 +1,79 @@
+// ─────────────────────────────────────────────────────────────
+// src/agency/revocation.ts  —  commitment-revocation tombstones
+// ─────────────────────────────────────────────────────────────
+//
+// EXAFFERENCE P4. When the world ruptures hard enough (rupture ≥
+// RUPTURE_REVOKE_GATE), the ActionSelector doesn't just soften its switch cost
+// (P3) — it *lets go* of a commitment it was still weighing: a `deliberating`
+// intent. But the selector cannot delete that intent directly. Registration
+// order is Selector → Deliberation → Executor, and each engine reads the frozen
+// tick-start snapshot, so a same-tick selector-delete + deliberation-set on the
+// same intent applies set-after-delete → the intent is RESURRECTED as `selected`
+// and enacted despite revocation (the P0 audit's resurrection race).
+//
+// The tombstone breaks that race by construction: the selector writes a SEPARATE
+// `agency.revocation` entity keyed by the intent id (no same-entity write). One
+// tick later both honorers see it from frozen state:
+//   • the Deliberation engine skips + deletes tombstoned `deliberating` intents;
+//   • the Executor refuses to enact a tombstoned `selected` intent (the half-race
+//     where deliberation committed `selected` the same tick the tombstone landed).
+// Revocation commits NO successor — the field re-forms and next tick selects.
+// A short TTL reaps a tombstone whose intent already vanished for another reason.
+// ─────────────────────────────────────────────────────────────
+
+import type { EntityInput, Tick } from '#core/types'
+
+export const REVOCATION_TYPE = 'agency.revocation'
+
+/** Rupture at/above which a still-deliberating commitment is revoked (rarer than
+ *  P3's recruitment-grade softening — letting go is a bigger step than easing up). */
+export const RUPTURE_REVOKE_GATE = 0.7
+
+/** Safety reap: a tombstone whose intent disappeared otherwise dies after this. */
+export const REVOCATION_TTL_TICKS = 5
+
+export function revocationId( intentId: string ): string {
+  return `agency-revocation-${ intentId }`
+}
+
+/** Build the tombstone for a revoked intent (keyed by intent id — one per intent). */
+export function revocationEntity(
+  intentId: string, schema: string, rupture: number, tick: Tick,
+): EntityInput {
+  return {
+    id:   revocationId( intentId ),
+    type: REVOCATION_TYPE,
+    metadata: { intentId, schema, rupture, tick, expiresAt: tick + REVOCATION_TTL_TICKS },
+  }
+}
+
+/** Intent ids under a live (unexpired) revocation tombstone, from frozen state. */
+export function revokedIntentIds(
+  entities: ReadonlyMap<string, { type: string; metadata?: ReadonlyMap<string, unknown> | Record<string, unknown> }>,
+  tick:     Tick,
+): Set<string> {
+  const out = new Set<string>()
+  for( const [ , e ] of entities ){
+    if( e.type !== REVOCATION_TYPE ) continue
+    const m = ( e.metadata ?? {} ) as Record<string, unknown>
+    const intentId = typeof m['intentId'] === 'string' ? m['intentId'] as string : undefined
+    const expiresAt = typeof m['expiresAt'] === 'number' ? m['expiresAt'] as number : 0
+    if( intentId && tick < expiresAt ) out.add( intentId )
+  }
+  return out
+}
+
+/** Ids of expired tombstones to sweep (TTL reap for intents that vanished otherwise). */
+export function staleRevocationIds(
+  entities: ReadonlyMap<string, { type: string; metadata?: ReadonlyMap<string, unknown> | Record<string, unknown> }>,
+  tick:     Tick,
+): string[] {
+  const stale: string[] = []
+  for( const [ id, e ] of entities ){
+    if( e.type !== REVOCATION_TYPE ) continue
+    const m = ( e.metadata ?? {} ) as Record<string, unknown>
+    const expiresAt = typeof m['expiresAt'] === 'number' ? m['expiresAt'] as number : 0
+    if( tick >= expiresAt ) stale.push( id )
+  }
+  return stale
+}

package/src/cognition/agency/schemas/repertoire.ts

@@ -167,7 +167,7 @@ export class SchemaRepertoire {
     const out: EntityInput[] = []
     for( const id of this._learned ){
       const s = this._templates.get( id )
-      if( s && s.kind === 'composite' ) out.push( schemaEntity( s ) )
+      if( s && s.kind === 'composite') out.push( schemaEntity( s ) )
     }
     return out
   }
@@ -242,7 +242,7 @@ function readSchema( m: Record<string, unknown> | undefined ): MotorSchema | und
   const meta = m ?? {}
   const id   = typeof meta['id'] === 'string' ? meta['id'] as string : undefined
   const kind = meta['kind']
-  if( !id || ( kind !== 'composite' && kind !== 'primitive' ) ) return undefined
+  if( !id || ( kind !== 'composite' && kind !== 'primitive') ) return undefined
   return {
     id,
     kind,

package/src/cognition/agency/selection.scoring.ts

@@ -7,13 +7,18 @@
 // learned, and what it fears. This is the basal-ganglia Go/NoGo arithmetic,
 // kept pure so it is trivially testable and replay-deterministic.
 //
-//   activation = goalRelevance + expectedReward + novelty + driveUrgency
+//   activation = goalRelevance
+//              + expectedReward
+//              + novelty
+//              + driveUrgency
 //              + habitStrength·W                              (additive habit bonus)
 //              + planBias·W                                   (top-down prior)
-//              − cost − inhibition − risk
+//              − cost
+//              − inhibition
+//              − risk
 //
 // The habit term is additive (per design decision): an overlearned schema wins
-// cheaply AND lowers its own deliberation threshold (see selector.ts), which is
+// cheaply AND lowers its own deliberation threshold (see action.selector.ts), which is
 // how the instrumental→habitual gradient cashes out as falling LLM spend.
 // ─────────────────────────────────────────────────────────────
 
@@ -77,22 +82,29 @@ export const DEFAULT_TEMPERATURE = 0.15
  */
 export function collectGoalTargets( state: ReadonlySimulationState ): Map<string, number> {
   const targets = new Map<string, number>()
+
   for( const e of state.entities.values() ){
-    if( e.type !== 'goal' ) continue
+    if( e.type !== 'goal') continue
+
     const m = e.metadata as Record<string, unknown> | undefined
     const status = typeof m?.['status'] === 'string' ? m['status'] : undefined
-    if( status !== 'active' && status !== 'in_progress' ) continue
+
+    if( status !== 'active' && status !== 'in_progress') continue
+
     const priority = typeof m?.['priority'] === 'number' ? m['priority'] as number : 0
     const link = ( id: unknown ): void => {
       if( typeof id !== 'string' || !id ) return
       targets.set( id, Math.max( targets.get( id ) ?? 0, priority ) )
     }
+
     link( m?.['targetEntityId'] )
     link( m?.['requestingEntityId'] )
+
     if( Array.isArray( m?.['tags'] ) )
       for( const t of m['tags'] as unknown[] )
-        if( typeof t === 'string' && t.startsWith( 'keid:' ) ) link( t.slice( 5 ) )
+        if( typeof t === 'string' && t.startsWith('keid:') ) link( t.slice( 5 ) )
   }
+
   return targets
 }
 
@@ -100,18 +112,22 @@ export function collectGoalTargets( state: ReadonlySimulationState ): Map<string
 export function goalRelevance( a: Affordance, bias: BiasContext ): number {
   if( a.targetEntityId && bias.goalTargets.has( a.targetEntityId ) )
     return bias.maxGoalPriority
+
   return 0
 }
 
 /** Homeostatic urgency routed to the affordance by its schema tags. */
 export function driveUrgency( a: Affordance, bias: BiasContext ): number {
   const t = a.tags
-  if( t.includes( 'regulatory' ) || t.includes( 'self-care' ) || t.includes( 'rest' ) )
+  if( t.includes('regulatory') || t.includes('self-care') || t.includes('rest') )
     return Math.max( bias.drives.energy, bias.drives.sleep )
-  if( t.includes( 'social' ) )
+
+  if( t.includes('social') )
     return bias.drives.social
-  if( t.includes( 'self-protection' ) )
+
+  if( t.includes('self-protection') )
     return Math.max( bias.drives.stress, bias.threat )
+
   return 0
 }
 

package/src/cognition/bus.ts

@@ -73,11 +73,11 @@ interface Subscription {
 }
 
 function topicMatches( pattern: string, topic: string ): boolean {
-  if( pattern === '*' ) return true   // global workspace subscription
+  if( pattern === '*') return true   // global workspace subscription
   if( pattern === topic ) return true
   if( pattern.endsWith('.*') ){
     const prefix = pattern.slice( 0, -2 )
-    return topic === prefix || topic.startsWith( prefix + '.' )
+    return topic === prefix || topic.startsWith( prefix + '.')
   }
   return false
 }

package/src/cognition/completion.inbox.ts

@@ -70,7 +70,7 @@ export class CompletionInbox {
     for( const { label, apply } of batch ){
       try { apply() }
       catch( err ){
-        logger.error( `[completion-inbox] "${label}" failed while landing at tick ${tick}:`, err )
+        logger.error(`[completion-inbox] "${label}" failed while landing at tick ${tick}:`, err )
       }
     }
 

package/src/cognition/config.mirror.entities.ts

@@ -21,11 +21,11 @@ export interface EngineConfigEntity {
 }
 
 export function buildEngineConfigEntities( config: WillConfig, executiveInterval: number ): EngineConfigEntity[] {
-  const selfBelonging  = parseFloat( process.env.WILL_SELF_BELONGING  ?? '0.35' )
-  const boredomRate    = parseFloat( process.env.WILL_BOREDOM_RATE    ?? '0.005' )
-  const curiosityFloor = parseFloat( process.env.WILL_CURIOSITY_FLOOR ?? '0.08' )
-  const summaryInterval   = parseInt( process.env.WILL_SUMMARY_INTERVAL   ?? '10' )
-  const summaryBufferSize = parseInt( process.env.WILL_SUMMARY_BUFFER_SIZE ?? '12' )
+  const selfBelonging  = parseFloat( process.env.WILL_SELF_BELONGING  ?? '0.35')
+  const boredomRate    = parseFloat( process.env.WILL_BOREDOM_RATE    ?? '0.005')
+  const curiosityFloor = parseFloat( process.env.WILL_CURIOSITY_FLOOR ?? '0.08')
+  const summaryInterval   = parseInt( process.env.WILL_SUMMARY_INTERVAL   ?? '10')
+  const summaryBufferSize = parseInt( process.env.WILL_SUMMARY_BUFFER_SIZE ?? '12')
 
   return [
     // ── System metadata ──────────────────────────────────────────

package/src/cognition/event.log.ts

@@ -84,7 +84,7 @@ export class DefaultEventLog implements EventLog {
   }
 
   private async _writeBatch( batch: CognitiveEvent[] ): Promise<void> {
-    const lines  = batch.map( e => JSON.stringify( e ) ).join( '\n' ) + '\n'
+    const lines  = batch.map( e => JSON.stringify( e ) ).join('\n') + '\n'
     let existing = ''
 
     try {
@@ -92,7 +92,7 @@ export class DefaultEventLog implements EventLog {
         existing = await this._storage.read( this._path )
     } catch { /* file may not exist yet */ }
 
-    await this._storage.ensureDir?.( this._path.replace( /\/[^/]+$/, '' ) )
+    await this._storage.ensureDir?.( this._path.replace( /\/[^/]+$/, '') )
     await this._storage.write( this._path, existing + lines )
   }
 }