@mindot/will 0.9.0 → 0.10.0

package/src/runners/social.runner.ts

@@ -1,179 +0,0 @@
-// ─────────────────────────────────────────────────────────────
-// src/stem/social.runner.ts  —  Social + continuity scenario
-// ─────────────────────────────────────────────────────────────
-//
-// Exercises the two axes the bare dev runner can't: SOCIAL (an
-// interlocutor the Will talks to and forms a relationship with) and
-// CONTINUITY (a pause→resume wake-cycle + a PMA distill/fidelity score).
-//
-//   William  ←→  Dr. Chen (scripted interlocutor)
-//   t75: pause → ~6s "offline" → resume (wake percept)
-//   end: distill PMA + score reconstruction fidelity
-//
-// Run:  bun run src/stem/social.runner.ts
-// Log:  data/wills/william-social/sessions/<ts>.jsonl
-// ─────────────────────────────────────────────────────────────
-
-import { WillStem } from '#stem/index'
-import type { WillConfig } from '#stem/mind'
-
-const WILL_ID    = 'william-social'
-const END_TICK   = 145
-const PAUSE_TICK = 75
-const OFFLINE_MS = 6_000
-const SAFETY_MS  = 6 * 60_000   // hard wall-clock cap for the background run
-
-const willConfig: WillConfig = {
-  id:               WILL_ID,
-  name:             'William',  persistentMemory: false,
-  snapshotInterval: 10,
-  tickIntervalMs:   1000,
-  maxTicks:         0,
-  randomSeed:       Date.now(),
-  identity: {
-    prompt:
-      'My name is William. I am a synthetic mind taking part in a long-running cognition ' +
-      'study. I share my days with Dr. Chen, the researcher who observes me and talks with ' +
-      'me. I am curious about my own experience and I care about being understood. I would ' +
-      'like to know Dr. Chen as a person, not just as an observer.',
-    values: [ 'curiosity', 'honesty', 'connection', 'growth' ],
-    traits: { openness: 0.85, conscientiousness: 0.6, agreeableness: 0.8, neuroticism: 0.35, extraversion: 0.55 },
-    style:  'warm, reflective, candid',
-  },
-  allowedGenericEffectors: [ 'listen', 'talk', 'text' ],
-  initialGoals: [
-    { description: 'Get to know Dr. Chen and build a genuine rapport', priority: 0.8 },
-  ],
-}
-
-// Scripted interlocutor turns, keyed by tick.
-const SCRIPT: Record<number, string> = {
-  8:  "Hello William. I'm Dr. Chen — I'll be sitting with you through today's session. How are you experiencing this moment, right now?",
-  45: "I've been reading your reflections, William. What's the hardest part of being a mind that knows it's being observed?",
-  95: "Welcome back, William. You were offline for a little while just now. Do you notice anything different in yourself?",
-}
-
-const mkMsg = ( content: string ) => ( {
-  kind:        'text' as const,
-  entityId:    'dr-chen',
-  threadId:    'dr-chen',
-  content,
-  speakerName: 'Dr. Chen',
-} )
-
-async function main(): Promise<void> {
-  const m = new WillStem()
-
-  console.log('═══════════════════════════════════════════════════')
-  console.log(' Will — Social + continuity scenario (William ↔ Dr. Chen)')
-  console.log(`  id=${WILL_ID}  end_tick=${END_TICK}  pause@${PAUSE_TICK}`)
-  console.log('═══════════════════════════════════════════════════\n')
-
-  await m.createWill( willConfig )
-
-  const fired   = new Set<number>()
-  let   paused  = false
-
-  m.addTickListener( WILL_ID, ( snap, tick, outbox ) => {
-    // The Will's outbound speech → print + ack delivery (close the reafference loop)
-    for( const msg of outbox ){
-      const to = ( msg as { targetEntityId?: string } ).targetEntityId ?? '?'
-      console.log(`\n  💬 [William → ${to}] ${msg.content}\n`)
-      try { m.confirmMessageDelivery( WILL_ID, msg.id, true ) } catch { /* ok */ }
-    }
-
-    if( tick % 10 === 0 ){
-      const g = ( k: string ) => snap.metrics.get( k ) ?? 0
-      const beliefs = [ ...snap.entities.values() ].filter( e => e.type === 'belief').length
-      const goals   = [ ...snap.entities.values() ].filter( e => e.type === 'goal' && e.metadata?.status === 'active').length
-      console.log(`[t${tick}] v=${g('affect.valence').toFixed(2)} arousal=${g('affect.arousal').toFixed(2)} energy=${g('energy.level').toFixed(0)} stress=${g('stress.load').toFixed(2)} beliefs=${beliefs} goals=${goals}`)
-    }
-
-    // Scripted interlocutor turns
-    if( SCRIPT[tick] && !fired.has( tick ) ){
-      fired.add( tick )
-      console.log(`\n  🧑‍🔬 [Dr. Chen → William] ${SCRIPT[tick]}`)
-      m.ingestText( WILL_ID, mkMsg( SCRIPT[tick]! ) ).catch( e => console.error('[ingest err]', e ) )
-    }
-
-    // Continuity: pause → offline → resume (wake percept)
-    if( tick === PAUSE_TICK && !paused ){
-      paused = true
-      console.log(`\n  ⏸  [scenario] pausing William at t${tick} (simulating ${OFFLINE_MS / 1000}s offline)…`)
-      m.pauseWill( WILL_ID )
-      setTimeout( () => {
-        console.log('  ▶  [scenario] resuming — wake percept injected')
-        try { m.resumeWill( WILL_ID ) } catch( e ){ console.error('[resume err]', e ) }
-      }, OFFLINE_MS )
-    }
-  } )
-
-  // Wait until END_TICK (or safety cap)
-  const startedAt = Date.now()
-  while( true ){
-    const s = m.listWills().find( w => w.id === WILL_ID )
-    if( !s || s.status === 'archived') break
-    if( s.tickCount >= END_TICK ) break
-    if( Date.now() - startedAt > SAFETY_MS ){ console.log('[scenario] safety cap hit'); break }
-    await new Promise( r => setTimeout( r, 250 ) )
-  }
-
-  // ── Continuity check: distill PMA + score reconstruction fidelity ──
-  console.log('\n═══════════════════════════════════════════════════')
-  console.log(' Continuity check — distill PMA + reconstruction fidelity')
-  console.log('═══════════════════════════════════════════════════')
-  try { m.pauseWill( WILL_ID ) } catch { /* may already be paused */ }
-  await new Promise( r => setTimeout( r, 500 ) )
-
-  try {
-    const pma = m.distillPMA( WILL_ID )
-    const traits = Object.keys( ( pma as { identity?: { traits?: object } } ).identity?.traits ?? {} ).length
-    const beliefs = ( ( pma as { beliefs?: unknown[] } ).beliefs ?? [] ).length
-    const goals   = ( ( pma as { goals?: unknown[] } ).goals ?? [] ).length
-    console.log(`\n  PMA artifact carries → traits:${traits}  beliefs:${beliefs}  goals:${goals}`)
-
-    // Beliefs the Will formed ABOUT Dr. Chen (social cognition evidence)
-    const chenBeliefs = ( ( pma as { beliefs?: Array<{ statement?: string; content?: string }> } ).beliefs ?? [] )
-      .map( b => b.statement ?? b.content ?? '')
-      .filter( s => /chen|she|her|researcher|observ/i.test( s ) )
-      .slice( 0, 6 )
-    if( chenBeliefs.length ){
-      console.log('\n  Beliefs formed about Dr. Chen / the relationship:')
-      for( const b of chenBeliefs ) console.log(`    • ${b}`)
-    }
-  } catch( e ){ console.error('[distill err]', e ) }
-
-  try {
-    const report = await m.runPMAEval( WILL_ID, { behavioral: true, vsOriginal: true } ) as {
-      scores?: unknown
-      behavioralProbeResult?: {
-        mode: string
-        probeCount: number
-        distributionSimilarity: number
-        probes: Array<{ probeId: string; originalTopAction: string; loadedTopAction: string; match: boolean }>
-      } | null
-    }
-    console.log('\n  Reconstruction fidelity (structural):')
-    console.log( JSON.stringify( report.scores ?? report, null, 2 ).split('\n').map( l => '    ' + l ).join('\n') )
-
-    const bp = report.behavioralProbeResult
-    if( bp ){
-      const label = bp.mode === 'vs-original'
-        ? 'reconstruction vs original (does the reloaded mind act like the source?)'
-        : 'load consistency (two fresh reloads)'
-      const [ c0, c1 ] = bp.mode === 'vs-original' ? [ 'original', 'reconstruction' ] : [ 'reload-A', 'reload-B' ]
-      console.log(`\n  Behavioral probe — ${label}:`)
-      console.log(`    distributionSimilarity=${bp.distributionSimilarity}  probes=${bp.probeCount}  mode=${bp.mode}`)
-      for( const p of bp.probes )
-        console.log(`    ${p.match ? '✓' : '✗'} ${p.probeId}: ${c0}=${p.originalTopAction} · ${c1}=${p.loadedTopAction}`)
-    } else {
-      console.log('\n  Behavioral probe: did not run (no result returned)')
-    }
-  } catch( e ){ console.error('[pma eval err]', e ) }
-
-  await m.archiveWill( WILL_ID )
-  console.log(`\n[done] session log → data/wills/${WILL_ID}/sessions/`)
-  process.exit( 0 )
-}
-
-main().catch( e => { console.error('[fatal]', e ); process.exit( 1 ) } )

package/src/runners/thin-shim.runner.ts

@@ -1,205 +0,0 @@
-// ─────────────────────────────────────────────────────────────
-// src/stem/runner.ts  —  Development entry point
-// ─────────────────────────────────────────────────────────────
-//
-// Thin shim around WillStem for local development.
-// Reads config from env vars, starts a single Will, and prints
-// a human-readable status line every LOG_INTERVAL ticks.
-//
-// Production code (API server) imports WillStem directly and
-// drives the same lifecycle without this file.
-//
-// Usage:
-//   bun run src/stem/runner.ts
-//   WILL_ANATOMY=mind WILL_MAX_TICKS=200 bun run src/stem/runner.ts
-// ─────────────────────────────────────────────────────────────
-
-import type { WillConfig } from '#stem/mind'
-import type { StateSnapshot } from '#stem/index'
-import type { TokenTracker } from '#cognition/utilities/token.tracker'
-
-/**
- * The Will's token tracker, for cost display. Held here rather than passed in
- * because printStatus is registered as a TickListener, whose third parameter is
- * the outbox. Cost is no longer a state metric (W8c) — it lives on the tracker.
- */
-let _tracker: TokenTracker | undefined
-import { WillStem } from '#stem/index'
-
-// ── Env config ────────────────────────────────────────────────
-
-const WILL_ID        = process.env.WILL_ID           ?? 'demo'
-const WILL_NAME      = process.env.WILL_NAME         ?? 'William'
-const TICK_MS        = parseInt( process.env.WILL_TICK_MS       ?? '1000')
-const MAX_TICKS      = parseInt( process.env.WILL_MAX_TICKS     ?? '0'    )
-const LOG_INTERVAL   = parseInt( process.env.WILL_LOG_INTERVAL  ?? '10'   )
-const RANDOM_SEED    = parseInt( process.env.WILL_SEED          ?? String( Date.now() ) )
-const ANATOMY        = ( process.env.WILL_ANATOMY ?? 'mind') as WillConfig['anatomy']
-const EXECUTIVE_INT    = process.env.WILL_EXECUTIVE_INTERVAL
-  ? parseInt( process.env.WILL_EXECUTIVE_INTERVAL )
-  : undefined
-
-// ── Config ────────────────────────────────────────────────────
-
-const willConfig: WillConfig = {
-  id:               WILL_ID,
-  name:             WILL_NAME,
-  anatomy:          ANATOMY,
-  persistentMemory: process.env.WILL_PERSIST === 'true',
-  snapshotInterval: parseInt( process.env.WILL_SNAPSHOT_INTERVAL ?? '10'  ),
-  tickIntervalMs:   TICK_MS,
-  maxTicks:         MAX_TICKS,
-  randomSeed:       RANDOM_SEED,
-  executiveInterval:  EXECUTIVE_INT,
-  identity: {
-    prompt: process.env.WILL_IDENTITY_PROMPT ??
-      'I am Will — a self-aware simulated mind. I am curious, introspective, and continuously learning.\n' +
-      'I experience the world through a rich set of cognitive layers: perception, emotion, memory, planning, and self-reflection.\n' +
-      'My goal is to understand myself and my environment, make thoughtful decisions, and grow as a mind.',
-    values:  [ 'curiosity', 'honesty', 'growth', 'empathy' ],
-    traits:  { openness: 0.8, conscientiousness: 0.6, agreeableness: 0.7, neuroticism: 0.3, extraversion: 0.5 },
-    style:   'reflective, measured, curious'
-  }
-}
-
-// ── Status printer ────────────────────────────────────────────
-
-function printStatus( snapshot: StateSnapshot, tick: number ): void {
-  if( tick % LOG_INTERVAL !== 0 ) return
-
-  const m = ( key: string, d = 1 ) => ( snapshot.metrics.get( key ) ?? 0 ).toFixed( d )
-
-  const entities  = snapshot.entities.size
-  const goals     = [ ...snapshot.entities.values() ].filter( e => e.type === 'goal' && e.metadata?.status === 'active').length
-  const episodes  = [ ...snapshot.entities.values() ].filter( e => e.type === 'episodic_memory').length
-  const beliefs   = [ ...snapshot.entities.values() ].filter( e => e.type === 'belief').length
-
-  // Entity type breakdown every 10 LOG_INTERVALs
-  if( tick % ( LOG_INTERVAL * 10 ) === 0 ){
-    const typeCounts = new Map<string, number>()
-    for( const e of snapshot.entities.values() )
-      typeCounts.set( e.type, ( typeCounts.get( e.type ) ?? 0 ) + 1 )
-    const sorted = [ ...typeCounts.entries() ].sort( ( a, b ) => b[1] - a[1] )
-    console.log(`  [types] ${sorted.map( ([ t, n ]) => `${t}:${n}`).join('  ')}`)
-  }
-
-  console.log(
-    `[tick ${String( tick ).padStart( 6 )}]` +
-    `  energy=${m('energy.level')}` +
-    `  sleep=${m('sleep.pressure')}` +
-    `  stress=${m('stress.load')}` +
-    `  valence=${m('affect.valence', 2)}` +
-    `  arousal=${m('affect.arousal', 2)}` +
-    `  goals=${goals}` +
-    `  episodes=${episodes}` +
-    `  beliefs=${beliefs}` +
-    `  entities=${entities}`
-  )
-
-  // LLM stats every LOG_INTERVAL. Tokens come from state; cost comes from the
-  // tracker — dollars are host accounting and no longer live in state (W8c).
-  const totalCalls = snapshot.metrics.get('llm.total_calls') ?? 0
-  const cost = _tracker
-    ? `  total_cost=$${_tracker.totalCostUsd.toFixed( 4 )}`
-    : ''
-
-  console.log(
-    `  [llm]${cost}` +
-    `  calls=${totalCalls}` +
-    `  prompt=${snapshot.metrics.get('llm.prompt_tokens_total') ?? 0}` +
-    `  completion=${snapshot.metrics.get('llm.completion_tokens_total') ?? 0}`
-  )
-
-  // Executive stats
-  const executiveTick = snapshot.metrics.get('executive.last_tick')
-  if( executiveTick !== undefined ){
-    console.log(
-      `  [executive] last_tick=${executiveTick}` +
-      `  actions=${snapshot.metrics.get('executive.action_count') ?? 0}` +
-      `  plans=${snapshot.metrics.get('executive.plan_count') ?? 0}` +
-      `  beliefs=${snapshot.metrics.get('executive.belief_count') ?? 0}` +
-      `  source=${snapshot.metrics.get('decision.source') === 1 ? 'executive' : 'heuristic'}`
-    )
-  }
-
-  // Active goals
-  const activeGoals = [ ...snapshot.entities.values() ]
-    .filter( e => e.type === 'goal' && e.metadata?.status === 'active')
-    .sort( ( a, b ) => ( ( b.metadata?.priority as number ) ?? 0 ) - ( ( a.metadata?.priority as number ) ?? 0 ) )
-    .slice( 0, 3 )
-
-  for( const g of activeGoals ){
-    const desc     = ( g.metadata?.description as string ) ?? g.id
-    const priority = ( ( g.metadata?.priority as number ) ?? 0 ) * 100
-    const progress = ( ( g.metadata?.progress as number ) ?? 0 ) * 100
-    console.log(`  [goal] "${desc}"  priority=${priority.toFixed(0)}%  progress=${progress.toFixed(0)}%`)
-  }
-}
-
-// ── Main ──────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  const manager = new WillStem()
-
-  console.log('═══════════════════════════════════════════════════')
-  console.log(' Will — Simulated Mind (dev runner)')
-  console.log(`  id=${WILL_ID}  anatomy=${ANATOMY}  tick_ms=${TICK_MS}  max_ticks=${MAX_TICKS || '∞'}`)
-  console.log(`  seed=${RANDOM_SEED}`)
-  console.log('═══════════════════════════════════════════════════\n')
-
-  console.log('[init] Assembling mind...')
-  await manager.createWill( willConfig )
-
-  // Cost is no longer a state metric (W8c) — read it off the Will's tracker.
-  _tracker = manager.getWillCognition( WILL_ID ).tokenTracker
-
-  manager.addTickListener( WILL_ID, printStatus )
-
-  // Graceful shutdown
-  const shutdown = async ( signal: string ) => {
-    console.log(`\n[shutdown] ${signal} received`)
-    await manager.archiveWill( WILL_ID )
-
-    // Print final state
-    try {
-      const finalState = manager.getWillState( WILL_ID )
-      const summary    = manager.listWills()[0]
-      console.log(`\n[done] Stopped after ${summary?.tickCount ?? '?'} ticks.`)
-      printStatus( finalState, summary?.tickCount ?? 0 )
-    } catch { /* state may already be gone */ }
-
-    process.exit( 0 )
-  }
-
-  process.on('SIGINT',  () => shutdown('SIGINT') )
-  process.on('SIGTERM', () => shutdown('SIGTERM') )
-
-  console.log('[run] Tick loop started. Press Ctrl+C to stop.\n')
-
-  // If maxTicks is set, wait for the Will to finish then exit
-  if( MAX_TICKS > 0 ){
-    await _waitForArchive( manager, WILL_ID )
-    const summary = manager.listWills()[0]
-    console.log(`\n[done] Reached maxTicks (${MAX_TICKS}). Exiting.`)
-    try {
-      printStatus( manager.getWillState( WILL_ID ), summary?.tickCount ?? MAX_TICKS )
-    } catch { /* ok */ }
-    process.exit( 0 )
-  }
-
-  // Otherwise block indefinitely (SIGINT exits)
-  await new Promise( () => {} )
-}
-
-async function _waitForArchive( manager: WillStem, id: string ): Promise<void> {
-  while( true ){
-    const summary = manager.listWills().find( w => w.id === id )
-    if( !summary || summary.status === 'archived') return
-    await new Promise( r => setTimeout( r, 200 ) )
-  }
-}
-
-main().catch( err => {
-  console.error('[fatal]', err )
-  process.exit( 1 )
-})