@mindot/will 0.9.0 → 0.10.0

package/src/cognition/faculties/affective.blender.ts

@@ -47,6 +47,21 @@ const ACP_CONFIDENCE     = 0.4
  * Numeric encoding for dominant emotion metric.
  * Consumers decode using DOMINANT_EMOTION_LABELS[code].
  */
+/**
+ * The entity carrying the non-numeric side of affect — what the mind is feeling,
+ * by name.
+ *
+ * Exported as a CONSTANT because the id is a contract between two files and it
+ * silently broke: `context.ts` read `state.entities.get('affective-state')`, an
+ * id nothing has ever written, so `dominantEmotion` fell back to 'neutral' in
+ * every prompt ever rendered. Measured live: a COO sitting at frustration 1.000
+ * and boredom 1.000 was told "Dominant emotion: neutral".
+ *
+ * Two string literals in two files cannot disagree if there is only one.
+ */
+export const AFFECT_STATE_ID   = 'affect-blends'
+export const AFFECT_STATE_TYPE = 'affect.blends'
+
 const DOMINANT_EMOTION_CODES: Record<string, number> = {
   'neutral':       0,
   'fear':          1,
@@ -381,11 +396,13 @@ export class AffectiveBlender implements SimulationEngine, CognitiveEngine {
     const dominantCode = DOMINANT_EMOTION_CODES[ dominant ?? 'neutral' ] ?? 0
     commands.metrics!.push([ 'affect.dominant_emotion', dominantCode ])
 
-    // Persist active blends as a state entity so the executive bridge can read them
+    // The mind's own read on what it is feeling, as an entity the executive can
+    // render. `dominantEmotion` is written as the LABEL, not the code: the code
+    // goes to metrics for telemetry, and a prompt cannot say "I feel 20".
     commands.set!.push({
-      id: 'affect-blends',
-      type:     'affect.blends',
-      metadata: { blends },
+      id:   AFFECT_STATE_ID,
+      type: AFFECT_STATE_TYPE,
+      metadata: { dominantEmotion: dominant ?? 'neutral', blends },
     })
 
     // 8. Track emotion history for blending detection

package/src/cognition/faculties/circadian.oscillator.ts

@@ -41,7 +41,22 @@ export interface CircadianConfig {
   /** Whether external light signals entrain the oscillator */
   entrainable?: boolean
   /** Current simulated time of day in hours (0-24). If not provided, derived from tick. */
-  timeOfDayHours?: number
+  /**
+   * The hour of day, 0–24. A NUMBER freezes it; a FUNCTION is read every tick,
+   * which is what a host with a real clock should pass.
+   *
+   * WHY THIS IS THE HOST'S TO SUPPLY. Left unset, the oscillator derives the
+   * hour from the tick count (1 tick = 1 second), which makes it *hours since
+   * tick zero, mod 24* — and after a snapshot restore, tick zero is an
+   * arbitrary point in a previous life. A mind reasoning about whether anyone
+   * is awake right now was reasoning from that.
+   *
+   * A circadian oscillator is a BODY RHYTHM, not a clock. It models what a body
+   * does over a day; it cannot know what day it is or where on Earth it runs.
+   * What time it is, is a fact about the world — afference — and arrives the
+   * way `environment.light_level` already does: from whoever can see it.
+   */
+  timeOfDayHours?: number | ( () => number )
   bus?: CognitiveBus
 }
 
@@ -51,7 +66,7 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
   private _periodHours: number
   private _phaseOffsetHours: number
   private _entrainable: boolean
-  private _timeOfDayHours?: number
+  private _timeOfDayHours?: number | ( () => number )
 
   private _bus: CognitiveBus | null = null
 
@@ -100,8 +115,11 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
     events:   Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = [],
     commands: StateCommands = { metrics: [] }
 
-    // Determine current time of day
-    let timeOfDay = this._timeOfDayHours
+    // Determine current time of day. A function is re-read every tick — a host
+    // clock moves; a config value does not.
+    let timeOfDay = typeof this._timeOfDayHours === 'function'
+      ? normalizeHour( this._timeOfDayHours() )
+      : this._timeOfDayHours
 
     if( timeOfDay === undefined ){
       // Derive from tick, assuming 1 tick = 1 second
@@ -278,17 +296,28 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
    * Set the current time of day explicitly (for scenarios with controlled time).
    */
   setTimeOfDay( hours: number ): void {
-    this._timeOfDayHours = ( hours % 24 + 24 ) % 24
+    this._timeOfDayHours = normalizeHour( hours )
+  }
+
+  /** Read a live clock every tick instead of holding a fixed hour. */
+  setClock( clock: ( () => number ) | null ): void {
+    this._timeOfDayHours = clock ?? undefined
   }
 
   /**
    * Get the current circadian phase.
    */
   getPhase(): CircadianPhase {
-    const h = this._timeOfDayHours ?? 12
+    const h = typeof this._timeOfDayHours === 'function'
+      ? normalizeHour( this._timeOfDayHours() )
+      : this._timeOfDayHours ?? 12
     return h >= 6 && h < 12 ? 'morning'
          : h >= 12 && h < 17 ? 'afternoon'
          : h >= 17 && h < 21 ? 'evening'
          : 'night'
   }
-}
+}
+/** 0–24, wrapping — a host clock that hands over 25 or −1 must not poison the rhythm. */
+function normalizeHour( h: number ): number {
+  return Number.isFinite( h ) ? ( ( h % 24 ) + 24 ) % 24 : 12
+}

package/src/cognition/faculties/executive.engine/action.record.ts

@@ -0,0 +1,129 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/faculties/executive.engine/action.record.ts
+// ─────────────────────────────────────────────────────────────
+//
+// What became of what I did.
+//
+// The executive's prompt has a `## What Became Of What I Did` section (called
+// `## Recent Action Outcomes` until P3 renamed it after what it renders), a builder
+// for it, and a type for its data. `context.ts` fills it by scanning
+// `decision.record` entities that carry an `actionStatus`. Nothing in the engine
+// has ever written `actionStatus` — it is read in exactly one place and set in
+// none — so the section has never had a single row. Measured across every
+// prompt a live COO received over two runs: that section appears
+// 0 times, while `## What I've Said Lately` appears in all of them.
+//
+// So the mind could see what it had SAID and never what it had DONE. Its only
+// other record of its own doing is `## What I Have Been Choosing` (`## Recent
+// Actions` at the time), which is fed from
+// `output.actions` — the executive's DECISIONS — and is therefore a list of
+// intentions wearing the name of a history.
+//
+// A mind whose record of acting contains only intentions cannot tell an
+// intention from an act. Live, asked directly "have you completed that?", a COO
+// answered "Yes — it's done. I drafted the full v0.1 spec: user stories, command
+// surface, integration points, success metrics. Posted it to FKEM." She had
+// posted nothing; she had no effectors at all and could not have drafted
+// anything anywhere. Her deliberation history said "I produce the scoping doc
+// now" across twenty cycles, and nothing in her state said whether she had.
+//
+// This is the same distinction `pending` draws for utterances — attempting to
+// speak is not speaking (#124) — carried to acts in general. It is written from
+// the `action.outcome` the executive ALREADY receives (it subscribes to `*`) and
+// from an explicit withheld signal, and it is an ordinary entity, so it
+// snapshots and replays with the rest of the mind.
+// ─────────────────────────────────────────────────────────────
+
+import type { EntityInput, Tick } from '#core/types'
+
+export const ACTION_RECORD_TYPE = 'action.record'
+
+/**
+ * How many outcomes the mind carries.
+ *
+ * Matches the cap `context.ts` already applies when rendering, so the state
+ * holds what the prompt shows and no more — an unbounded history of everything
+ * ever done is a memory system, not a working record, and this is the latter.
+ */
+export const ACTION_RECORD_KEEP = 6
+
+/**
+ * `withheld` is a first-class outcome, not a flavour of failure.
+ *
+ * The mind considered an act, formed it, and chose not to complete it. Folding
+ * that into `failed` is the mistake #123 was written to correct — it taught a
+ * COO it was bad at speaking from the times it decided not to speak.
+ */
+export type ActionStatus = 'completed' | 'failed' | 'withheld'
+
+export interface ActionRecord {
+  type:            string
+  status:          ActionStatus
+  tick:            Tick
+  targetEntityId?: string
+  /** The mind's own account of what happened, in its words where it has any. */
+  outcome:         string
+  planId?:         string
+}
+
+/** Stable id — one record per (tick, act), so two acts on a tick both survive. */
+export function actionRecordId( tick: Tick, type: string, targetEntityId?: string ): string {
+  return `action-record-${ tick }-${ type }${ targetEntityId ? `-${ targetEntityId }` : '' }`
+}
+
+export function actionRecordEntity( r: ActionRecord ): EntityInput {
+  return {
+    id:   actionRecordId( r.tick, r.type, r.targetEntityId ),
+    type: ACTION_RECORD_TYPE,
+    metadata: { ...r },
+  }
+}
+
+/** Read a record back off entity metadata — every field, including the ones it is easy to forget. */
+export function readActionRecord(
+  m: ReadonlyMap<string, unknown> | Record<string, unknown> | undefined,
+): ActionRecord | null {
+  const meta = ( m instanceof Map ? Object.fromEntries( m ) : m ?? {} ) as Record<string, unknown>
+  const type   = typeof meta['type'] === 'string' ? meta['type'] as string : undefined
+  const status = meta['status']
+  if( !type || ( status !== 'completed' && status !== 'failed' && status !== 'withheld') ) return null
+
+  return {
+    type, status,
+    tick:           typeof meta['tick'] === 'number' ? meta['tick'] as number : 0,
+    targetEntityId: typeof meta['targetEntityId'] === 'string' ? meta['targetEntityId'] as string : undefined,
+    outcome:        typeof meta['outcome'] === 'string' ? meta['outcome'] as string : '',
+    planId:         typeof meta['planId'] === 'string' ? meta['planId'] as string : undefined,
+  }
+}
+
+/** The mind's recent acts, newest first. */
+export function recentActionRecords(
+  entities: ReadonlyMap<string, { type: string; metadata?: ReadonlyMap<string, unknown> | Record<string, unknown> }>,
+  keep:     number = ACTION_RECORD_KEEP,
+): ActionRecord[] {
+  const out: ActionRecord[] = []
+  for( const [ , e ] of entities ){
+    if( e.type !== ACTION_RECORD_TYPE ) continue
+    const r = readActionRecord( e.metadata )
+    if( r ) out.push( r )
+  }
+  // Newest first, ties broken by act name so a run and its replay agree.
+  out.sort( ( a, b ) => b.tick - a.tick || ( a.type < b.type ? -1 : a.type > b.type ? 1 : 0 ) )
+  return out.slice( 0, keep )
+}
+
+/** Records that have fallen off the end of the window — swept by the writer. */
+export function staleActionRecordIds(
+  entities: ReadonlyMap<string, { type: string; metadata?: ReadonlyMap<string, unknown> | Record<string, unknown> }>,
+  keep:     number = ACTION_RECORD_KEEP,
+): string[] {
+  const all: Array<{ id: string; r: ActionRecord }> = []
+  for( const [ id, e ] of entities ){
+    if( e.type !== ACTION_RECORD_TYPE ) continue
+    const r = readActionRecord( e.metadata )
+    if( r ) all.push({ id, r })
+  }
+  all.sort( ( a, b ) => b.r.tick - a.r.tick || ( a.r.type < b.r.type ? -1 : a.r.type > b.r.type ? 1 : 0 ) )
+  return all.slice( keep ).map( x => x.id )
+}

package/src/cognition/faculties/executive.engine/context.ts

@@ -2,6 +2,8 @@
 // src/cognition/faculties/executive.engine/context.ts
 // ─────────────────────────────────────────────────────────────
 
+import { recentActionRecords } from '#faculties/executive.engine/action.record'
+import { AFFECT_STATE_ID } from '#faculties/affective.blender'
 import type { ReadonlySimulationState } from '#core/types'
 import type { GoalManager } from '#faculties/goal.manager'
 import type { WorkingMemory } from '#faculties/working.memory'
@@ -53,7 +55,7 @@ export async function buildExecutiveContext(
 
   // Working memory — getItems() returns WMItem[] sorted by activation descending.
   // Filter types that are already rendered elsewhere in the prompt:
-  //   conversation.exchange → shown in Recent Action Outcomes
+  //   conversation.exchange → shown in What Became Of What I Did
   //   goal                  → shown in Active Goals
   const WM_FILTER_TYPES = new Set([ 'conversation.exchange', 'goal' ])
   const wmItems = ( deps.workingMemory?.getItems() ?? [] )
@@ -61,7 +63,12 @@ export async function buildExecutiveContext(
   const workingMemory = wmItems.map( item => ({
     type: item.type,
     summary: extractSummary( item.content ),
-    activation: item.activation
+    activation: item.activation,
+    // Storing the evidence in memory and then rendering only the label would
+    // lose it just as completely, one step later. A percept entity is swept
+    // after 2 ticks and the executive fires on its own schedule, so memory is
+    // often where the mind meets an observation at all.
+    ...( itemData( item.content ) !== undefined ? { data: itemData( item.content ) } : {} ),
   }))
 
   // Episodic memory — semantic query for relevant memories based on current goals
@@ -256,33 +263,15 @@ export async function buildExecutiveContext(
     impulsivity:     execParams.impulsivity     ?? 0.3,
   } : undefined
 
-  // Recent action outcomes — scan decision.record entities that have been processed
-  // (actionStatus is set) and return the last 5 most recent, newest first.
-  // This closes the Act → Confirm → Perceive loop: the executive can see what it
-  // tried, whether it landed, and whether an external dispatch went unanswered.
-  const recentActions: Array<{
-    type: string; status: 'completed' | 'failed' | 'awaiting_host' | 'timed_out'
-    tick: number; outcome: string; planId?: string
-  }> = []
-
-  for( const entity of state.entities.values() ){
-    if( entity.type !== 'decision.record') continue
-    const actionStatus = entity.metadata?.actionStatus as string | undefined
-    if( !actionStatus ) continue
-    if( !( [ 'completed', 'failed', 'awaiting_host', 'timed_out' ] as string[] ).includes( actionStatus ) ) continue
-
-    recentActions.push({
-      type:   ( entity.metadata?.actionType as string )    ?? 'unknown',
-      status: actionStatus as 'completed' | 'failed' | 'awaiting_host' | 'timed_out',
-      tick:   ( entity.metadata?.executionTick as number ) ?? ( entity.metadata?.dispatchedAt as number ) ?? 0,
-      outcome: String( entity.metadata?.outcome ?? '').slice( 0, 120 ),
-      planId: entity.metadata?.planId as string | undefined,
-    })
-  }
-
-  // Sort newest-first, cap at 5
-  recentActions.sort( ( a, b ) => b.tick - a.tick )
-  const recentActionsCapped = recentActions.slice( 0, 5 )
+  // What became of what I did — this is what closes the Act → Confirm → Perceive
+  // loop the prompt's `## What Became Of What I Did` section was written for.
+  //
+  // It used to scan `decision.record` for an `actionStatus`, a field READ here
+  // and written nowhere in the engine. The section therefore rendered zero times
+  // across every prompt a live COO ever received, while `## What I've Said
+  // Lately` rendered in all of them — the mind could see what it had said and
+  // never what it had done. See `action.record.ts` for what that cost.
+  const recentActionsCapped = recentActionRecords( state.entities as never )
 
   // Current best name for a person, from the known-entity roster.
   const nameOf = ( keid: string ): string | undefined => {
@@ -353,7 +342,11 @@ export async function buildExecutiveContext(
       sleepPressure: state.metrics.get('sleep.pressure') ?? 0,
       stressLoad: state.metrics.get('stress.load') ?? 0,
       circadianPhase: state.metrics.get('circadian.phase') ?? 0,
-      timeOfDay: state.metrics.get('time.of_day') ?? 12,
+      // `circadian.time_of_day`, not `time.of_day`. The oscillator has always
+      // written the first and this has always read the second, so the fallback
+      // fired on EVERY tick a Will has ever run: the prompt said `Time: 12.0h`
+      // — noon, permanently — beside a phase label that disagreed with it.
+      timeOfDay: state.metrics.get('circadian.time_of_day') ?? 12,
       // Tonic threat representation — survives event habituation (guardrail).
       threatLevel: state.metrics.get('threat.level') ?? 0
     },
@@ -623,6 +616,13 @@ function mapEpisodeToMemory( ep: {
   }
 }
 
+/** A working-memory item's host payload, when it carries one. */
+function itemData( content: unknown ): unknown {
+  if( content && typeof content === 'object')
+    return ( content as Record<string, unknown> )['data']
+  return undefined
+}
+
 function extractSummary( content: unknown ): string {
   if( typeof content === 'string')
     return content.slice( 0, 120 )
@@ -638,8 +638,8 @@ function extractSummary( content: unknown ): string {
   return String( content ?? '').slice( 0, 120 )
 }
 
-function extractPercepts( state: ReadonlySimulationState ): Array<{ category: string; summary: string; salience: number }> {
-  const percepts: Array<{ category: string; summary: string; salience: number }> = []
+function extractPercepts( state: ReadonlySimulationState ): Array<{ category: string; summary: string; salience: number; data?: unknown }> {
+  const percepts: Array<{ category: string; summary: string; salience: number; data?: unknown }> = []
 
   for( const entity of state.entities.values() ){
     if( entity.type !== 'percept' && entity.type !== 'percept.social') continue
@@ -652,6 +652,10 @@ function extractPercepts( state: ReadonlySimulationState ): Array<{ category: st
     percepts.push({
       category: (entity.metadata?.category as string) ?? 'general',
       summary,
+      // What the host actually sent, beside the label the engine wrote. A mind
+      // reasoning only from labels is reasoning from somebody else's summary of
+      // the evidence.
+      ...( entity.metadata?.data !== undefined ? { data: entity.metadata.data } : {} ),
       salience: (entity.metadata?.salience as number) ?? 0
     })
   }
@@ -672,12 +676,14 @@ function extractAffect( state: ReadonlySimulationState ): ExecutiveContext['affe
   const arousal   = state.metrics.get('affect.arousal')   ?? 0.5
   const dominance = state.metrics.get('affect.dominance') ?? 0.5
 
-  // Non-numeric affect data — read from the affective-state entity.
-  // AffectiveBlender writes this entity each tick with dominantEmotion and blends.
+  // Non-numeric affect data — read from the entity AffectiveBlender writes each
+  // tick. The id comes from the writer rather than being spelled again here: this
+  // read used to look for 'affective-state', which nothing has ever written, so
+  // both values silently took their fallbacks in every prompt ever rendered.
   let dominantEmotion = 'neutral'
   let blends: string[] = []
 
-  const affectEntity = state.entities.get('affective-state')
+  const affectEntity = state.entities.get( AFFECT_STATE_ID )
   if( affectEntity ){
     dominantEmotion = (affectEntity.metadata?.dominantEmotion as string) ?? 'neutral'
     blends = (affectEntity.metadata?.blends as string[]) ?? []