@mindot/will 0.8.0 → 0.10.0

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

@@ -53,6 +53,18 @@ export interface FacetReport {
   contextId?: string
   /** Optional dynamic instructions to append to the user message */
   instructions?: string
+  /**
+   * Attend to something else for THIS report only, leaving the facet's standing
+   * focus untouched.
+   *
+   * A facet's focus was a single mutable field, so anything that wanted a live
+   * facet to consider one different thing had to `setFocus()` first — clobbering
+   * whatever the facet was already set up for, and racing with any report already
+   * queued behind it. That is why a self-initiated message to someone the mind was
+   * ALREADY talking to had to be composed by a separate, transient facet that could
+   * not see the live conversation at all.
+   */
+  focus?: FocusSection
 }
 
 export interface FacetDecision {
@@ -63,6 +75,16 @@ export interface FacetDecision {
   decision: unknown
   reasoning: string
   confidence: number
+  /**
+   * Sim tick this decision was reasoned at.
+   *
+   * The facet has always known it and never passed it on, so a subscriber writing
+   * state in response had no deterministic clock and reached for a process-local
+   * counter instead — which resets on restart and collides. Never wall-clock: this
+   * reaches ids that live in state, and a wall-clock id makes recorded and replayed
+   * runs diverge (R2).
+   */
+  tick: number
 }
 
 export type FacetEventListener = ( decision: FacetDecision ) => void
@@ -134,6 +156,19 @@ export class ExecutiveFacet {
   private _facetReasoningHistory: string[] = []
   private _masterSyncHistory: string[] = []
 
+  /**
+   * This facet's own prior reasoning, for the supervisor to carry to whichever
+   * facet takes over the same keyed thread. Continuity belongs to the thread, not
+   * to the instance holding it: a facet reaped mid-conversation used to take the
+   * mind's private thinking about that person with it.
+   */
+  get reasoningHistory(): string[] { return [ ...this._facetReasoningHistory ] }
+
+  /** Resume a thread's reasoning on spawn (supervisor-only; see FacetSpawnDeps.key). */
+  restoreReasoningHistory( history: string[] ): void {
+    this._facetReasoningHistory = [ ...history ]
+  }
+
   /** Confidence of this facet's *previous* decision — a dual-process gate signal. */
   private _lastConfidence = 0.5
 
@@ -260,9 +295,7 @@ export class ExecutiveFacet {
   private _launchReason( report: FacetReport ): void {
     this._inflight++
     this._reason( report )
-      .catch( err =>
-        logger.error(`[executive.facet] ${this.facetId} reasoning error:`, err )
-      )
+      .catch( err => logger.error(`[executive.facet] ${this.facetId} reasoning error:`, err ) )
       .finally( () => {
         this._inflight--
         this.markActive( ( this._currentStateRef?.tick as number ) ?? this._lastActiveTick )
@@ -322,9 +355,14 @@ export class ExecutiveFacet {
 
     logger.info(`[executive.facet] ${this.facetId} synced from master (tick=${payload.tick})`)
 
-    // Store master's latest reasoning for context in next report()
+    // Store the wider reasoning for context in the next report().
+    //
+    // Rendered in the FIRST PERSON and with no mention of a "master": this is the
+    // same mind's thinking arriving from where the rest of its attention has been,
+    // not a report from a superior. Naming it "Master sync" gave the facet a second
+    // party to address — and it addressed it, out loud, on the outbound channel.
     if( payload.reasoning )
-      this._masterSyncHistory.push(`[Master sync — tick ${payload.tick}] ${payload.reasoning.slice( 0, 400 )}`)
+      this._masterSyncHistory.push(`[tick ${payload.tick}] ${payload.reasoning.slice( 0, 400 )}`)
 
     // Keep only last 5 sync entries
     if( this._masterSyncHistory.length > 5 )
@@ -338,7 +376,11 @@ export class ExecutiveFacet {
     if( !this._currentStateRef )
       throw new Error(`[executive.facet] ${this.facetId} no state reference available`)
 
-    if( !this._currentFocus )
+    // This report's focus: its own if it carried one, else the facet's standing
+    // one. A per-report focus never mutates `_currentFocus`, so a live thread can
+    // be asked to attend to one different thing and come straight back.
+    const reportFocus = report.focus ?? this._currentFocus
+    if( !reportFocus )
       throw new Error(`[executive.facet] ${this.facetId} no focus set. Call setFocus() before report().`)
 
     const currentState = this._currentStateRef
@@ -346,7 +388,7 @@ export class ExecutiveFacet {
     // Build fresh context from current state
     // A focus may supply a recall query (e.g. the live conversation message) to
     // drive the single "## Relevant Memories" section — one recall surface (§5).
-    const execContext = await PromptFactory.buildFreshContext( this._contextDeps, currentState, this._currentFocus?.recallQuery )
+    const execContext = await PromptFactory.buildFreshContext( this._contextDeps, currentState, reportFocus.recallQuery )
 
     const qualityModulation = PromptFactory.computeQualityModulation( currentState )
     const epistemicUncertainty = PromptFactory.computeEpistemicUncertainty( execContext, currentState )
@@ -355,10 +397,10 @@ export class ExecutiveFacet {
     // the appropriate content via setFocus()
     const focus: FocusSection = this._masterSyncHistory.length > 0
             ? {
-                ...this._currentFocus,
-                content: `${this._currentFocus.content}\n\n## Master Consciousness Updates\n${this._masterSyncHistory.join('\n')}`
+                ...reportFocus,
+                content: `${reportFocus.content}\n\n## What I've Been Turning Over\n${this._masterSyncHistory.join('\n')}`
               }
-            : this._currentFocus
+            : reportFocus
 
     // Build system prompt using PromptFactory — same schema as master, [REPLY] gated out.
     const systemPrompt = PromptFactory.buildSystemPrompt( {
@@ -377,7 +419,7 @@ export class ExecutiveFacet {
     // isn't cold on each cycle. Injected before the caller's instructions so the
     // caller content always comes last (highest recency bias from the LLM).
     const continuityBlock = this._facetReasoningHistory.length > 0
-      ? `## My Prior Reasoning (this facet)\n${this._facetReasoningHistory.join('\n')}`
+      ? `## Where My Thinking Had Got To\n${this._facetReasoningHistory.join('\n')}`
       : ''
 
     const reportContent = [
@@ -399,7 +441,7 @@ export class ExecutiveFacet {
       stressLoad:        currentState.metrics.get('stress.load') ?? 0,
       // A facet's "stakes-bearing moment" is a live message awaiting reply (conversation
       // facets set focus.recallQuery to it); planning/other facets rely on uncertainty.
-      hasPendingMessage: !!this._currentFocus?.recallQuery,
+      hasPendingMessage: !!reportFocus.recallQuery,
     }, deliberateThreshold )
 
     let ideationCandidates: IdeationCandidate[] | undefined
@@ -410,7 +452,6 @@ export class ExecutiveFacet {
         state: currentState,
         qualityModulation,
         epistemicUncertainty,
-        pendingMessages: [],
         focus,
         deps: this._promptDeps,
         recentActionTypes: [],
@@ -424,7 +465,14 @@ export class ExecutiveFacet {
         ideationUserMessage,
         tick: currentState.tick,
         proposeTemperature,
-        meta: { category: 'executive', attribute: 'facet', function: this._currentFocus?.function ?? 'ideation', scope: this.facetId, demand: processSelection.effortScore },
+        meta: {
+          category: 'executive',
+          attribute: 'facet',
+          process: 'ideation',
+          function: reportFocus.function ?? '-',
+          scope: this.facetId,
+          demand: processSelection.effortScore
+        },
       } )
       logger.info(
         `[executive.facet] ${this.facetId} ◆ deliberate propose tick=${currentState.tick}  ` +
@@ -437,7 +485,6 @@ export class ExecutiveFacet {
       state: currentState,
       qualityModulation,
       epistemicUncertainty,
-      pendingMessages: [],
       focus,
       deps: this._promptDeps,
       recentActionTypes: [],
@@ -471,11 +518,12 @@ export class ExecutiveFacet {
       const facetMeta: LLMCallMeta = {
         category:  'executive',
         attribute: 'facet',
+        process: 'decision',
         // A focus that declares no function is making its decision call, the
         // facet's analogue of master's 'decision'. This previously fell back to
         // 'facet' — an *attribute* value, which quietly created a bogus bucket
         // in the by-function cost breakdown. The typed axes caught it.
-        function:  this._currentFocus?.function ?? 'decision',
+        function:  reportFocus.function ?? '-',
         scope:     this.facetId,
         demand:    processSelection.effortScore,
       }
@@ -555,7 +603,8 @@ export class ExecutiveFacet {
       respondingToType: report.type,
       decision: this._extractDecisionPayload( output, focus ),
       reasoning: output.reasoning,
-      confidence: output.confidence
+      confidence: output.confidence,
+      tick: currentState.tick as unknown as number
     }
 
     // Promote subscriber-visible fields from the decision object to the event payload
@@ -566,7 +615,7 @@ export class ExecutiveFacet {
       ? decision.decision as Record<string, unknown>
       : {}
 
-    this._bus.publish( {
+    this._bus.publish({
       type: 'executive.facet.progress',
       version: 1,
       sourceEngine: `executive-facet-${this.facetId}`,
@@ -587,7 +636,7 @@ export class ExecutiveFacet {
         contextId:        report.contextId,
         tick:             currentState.tick
       }
-    } )
+    })
 
     // Conscious learning about others — route name/feeling to known.entity.tracker (the
     // dossier owner) the same way the master does, so routine (un-escalated) conversation
@@ -595,15 +644,17 @@ export class ExecutiveFacet {
     const keUpdates = dec[ 'knownEntityUpdates' ] as ExecutiveOutputFull['knownEntityUpdates'] | undefined
     if( keUpdates )
       for( const u of keUpdates )
-        if( u.keid && u.keid !== 'agent-self' && ( u.name || u.feeling != null ) )
-          this._bus.publish( {
-            type: 'known.entity.learned', version: 1,
+        if( u.keid && u.keid !== 'agent-self' && ( u.name || u.feeling != null || u.sameAs ) )
+          this._bus.publish({
+            type: 'known.entity.learned',
+            version: 1,
             sourceEngine: `executive-facet-${this.facetId}`,
-            salience: 0.5, payload: { keid: u.keid, name: u.name, feeling: u.feeling }
-          } )
+            salience: u.sameAs ? 0.7 : 0.5,
+            payload: { keid: u.keid, name: u.name, feeling: u.feeling, sameAs: u.sameAs }
+          })
 
     // Sync back to master
-    this._bus.publish( {
+    this._bus.publish({
       type: 'executive.facet.sync',
       version: 1,
       sourceEngine: `executive-facet-${this.facetId}`,
@@ -613,9 +664,13 @@ export class ExecutiveFacet {
         reasoning: output.reasoning,
         confidence: output.confidence,
         actionTypes: output.actions.map( a => a.type ),
+        // WHO this facet is engaged with (FocusSection.subject*). The master keeps
+        // the singular seat, so it needs the person, not just the facet number.
+        ...( focus.subjectEntityId ? { subjectEntityId: focus.subjectEntityId } : {} ),
+        ...( focus.subjectName     ? { subjectName:     focus.subjectName     } : {} ),
         tick: currentState.tick
       }
-    } )
+    })
 
     // Notify all listeners (PlanningEngine, AuditionEngine, etc.).
     //

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

@@ -2,7 +2,6 @@
 // src/cognition/faculties/executive.engine/gating.ts
 // ─────────────────────────────────────────────────────────────
 
-import type { PendingMessage } from '#faculties/executive.engine/types'
 import type { Tick, ReadonlySimulationState } from '#core/types'
 import type { GenerativeModel } from '#cognition/generative.model'
 import {
@@ -11,23 +10,28 @@ import {
 } from '#faculties/executive.engine/config'
 import type { CognitiveEvent } from '#cognition/bus'
 
-function hasPendingInstructions( state: ReadonlySimulationState, pendingMessages: PendingMessage[] ): boolean {
-  for( const entity of state.entities.values() ){
+/**
+ * Something in the world is loud enough to wake a resting mind.
+ *
+ * Percept salience is the whole test now. Two other wake sources used to sit here
+ * and neither could ever fire: an unprocessed `communication` entity (a type
+ * nothing has ever written) and a non-empty pending-message queue (never pushed
+ * to, and the current design forbids it — inbound reaches a facet, and the master
+ * learns of it through `executive.facet.handoff` → a high-salience percept, which
+ * this catches). Both removed with the queue itself (#114).
+ */
+function hasPendingInstructions( state: ReadonlySimulationState ): boolean {
+  for( const entity of state.entities.values() )
     if( entity.type === 'percept' || entity.type === 'percept.social'){
       const salience = (entity.metadata?.salience as number) ?? 0
       if( salience > 0.7 ) return true
     }
 
-    if( entity.type === 'communication' && !entity.metadata?.processedByExecutive )
-      return true
-  }
-
-  return pendingMessages.length > 0
+  return false
 }
 
 export interface GatingDependencies {
   generativeModel: GenerativeModel
-  pendingMessages: PendingMessage[]
   hasPendingWork: boolean
 }
 
@@ -110,7 +114,7 @@ export function evaluateGating(
   if( isResting > 0 || isSleeping > 0 ){
     const
     significantEvent = novelty > 0.8,
-    hasPending = hasPendingInstructions( state, deps.pendingMessages )
+    hasPending = hasPendingInstructions( state )
 
     if( significantEvent || hasPending )
       return {
@@ -142,10 +146,6 @@ export function evaluateGating(
   if( energy < 15 )
     return { shouldActivate: true, reason: 'energy_critical', cleanedBuffer }
 
-  // ── Pending messages — always fire ────────────────────────
-  if( deps.pendingMessages.length > 0 )
-    return { shouldActivate: true, reason: 'pending_message', cleanedBuffer }
-
   // ── Normal interval scheduling ────────────────────────────
   if( tick - gs.lastExecutiveTick >= gs.executiveInterval ){
     // Prediction-error gating — uses GenerativeModel.observe() which returns { gated }

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

@@ -3,7 +3,7 @@
 // ─────────────────────────────────────────────────────────────
 
 import { logger } from '#core/logger'
-import { REPLY_TEXT_TAG } from '#llm/wire.contracts'
+import { REPLY_TEXT_TAG, NO_MESSAGE_TAG, NO_MESSAGE_OPEN, stripProtocolMarkers } from '#llm/wire.contracts'
 import type { ReadonlySimulationState } from '#core/types'
 import type { ExecutiveOutputFull, ExecutiveOutputMinimal, IdeationCandidate, IdeationOutput } from '#faculties/executive.engine/types'
 
@@ -27,7 +27,9 @@ export function parseResponse(
 
   let
   actions: Array<{ type: string; reasoning: string; expectedOutcome: string }>,
-  confidence = 0.5
+  confidence = 0.5,
+  /** The mind's own sentence, when the response parsed as JSON and carried one. */
+  stated: string | undefined
 
   // Strategy 1: direct JSON.parse
   try {
@@ -41,6 +43,7 @@ export function parseResponse(
 
     actions = parsed.actions
     confidence = parsed.confidence ?? 0.5
+    stated = typeof parsed.reasoning === 'string' ? parsed.reasoning : undefined
   }
   catch {
     // Strategy 2: balanced-bracket extractor
@@ -60,14 +63,45 @@ export function parseResponse(
     confidence = confidenceMatch ? parseFloat( confidenceMatch[1]! ) : 0.5
   }
 
-  // Parse tagged blocks from the extracted JSON text
+  // Tagged blocks are scanned over the FULL text — they are documented as embedded
+  // in the reasoning field, but a model puts them wherever it likes and the scan
+  // has always been forgiving about that. Keep that surface.
   const full = parseTaggedBlocks({ actions, reasoning: fullText, confidence }, state )
 
+  // …but `reasoning` itself is the mind's SENTENCE, not its serialization.
+  //
+  // It was `fullText` — the whole JSON blob — for every consumer downstream, and
+  // that was invisible for as long as nothing read it as prose. Three things do:
+  // the session log records it, a facet is handed the master's as "What I've Been
+  // Turning Over" (clipped to 400 chars, so facets have been reading the master's
+  // JSON truncated mid-object), and the master now reads a facet's back as what it
+  // worked out. Seen live in a prompt: `What I worked out there: { "actions": [...
+  //
+  // The scan surface and the sentence were the same string only because nothing
+  // had ever needed them to be different.
+  // Stripped of the tagged blocks, because the format tells the mind to embed them
+  // IN this field — so the sentence and the structured payload arrive in one
+  // string, and handing the whole thing back as "what I worked out" would just
+  // move the serialization problem one level in.
+  if( stated ) full.reasoning = stripTaggedBlocks( stated )
+
   // [REPLY_TEXT] is a plain-text block that lives OUTSIDE the JSON code block.
   // Search the full response text so we find it even when the LLM used a code fence.
   const replyText = extractTextBlock( responseText, REPLY_TEXT_TAG )
   if( replyText ) full.replyText = replyText
 
+  // A declared decision not to speak. Its own field rather than an empty
+  // replyText, because "I chose silence" and "the facet produced nothing" are
+  // different events: one is a decision worth recording, the other a failure worth
+  // noticing, and collapsing them hides both.
+  // Presence of the MARKER is the decision — not the content, which may legitimately
+  // be empty. `extractTextBlock` returns null for an absent tag AND for a present
+  // but empty one, so it cannot tell them apart; testing it for undefined (as this
+  // first did) is true in every case and made the mind mute on every path. The
+  // integration suite caught it; a live boot would have caught it as total silence.
+  if( responseText.includes( NO_MESSAGE_OPEN ) )
+    full.noMessage = extractTextBlock( responseText, NO_MESSAGE_TAG ) ?? '(no reason given)'
+
   return full
 }
 
@@ -164,6 +198,29 @@ function extractBalancedArray( text: string, key: string ): string | null {
   return null
 }
 
+/** Every block name the reasoning field may carry, for stripping it back to prose. */
+const TAGGED_BLOCK_NAMES = [
+  'PLANS', 'BELIEFS', 'INTROSPECTION', 'NARRATIVE', 'IDENTITY', 'KNOWN_ENTITIES',
+  'GOALS_NEW', 'GOALS_ABANDON', 'GOALS_REPRIORITIZE', 'EFFECTORS', 'SELF_OBS',
+  'SKILLS', 'REPLY_TEXT', 'ACK',
+] as const
+
+/**
+ * The sentence, with the structured payload taken back out of it.
+ *
+ * Unclosed blocks are cut to the end of the string on purpose: a truncated
+ * `[PLANS]{…` is not prose either, and leaving it in puts half a JSON object in
+ * front of whoever reads this as the mind's thinking.
+ */
+export function stripTaggedBlocks( reasoning: string ): string {
+  let out = reasoning
+  for( const tag of TAGGED_BLOCK_NAMES )
+    out = out
+      .replace( new RegExp( `\\[${ tag }\\][\\s\\S]*?\\[/${ tag }\\]`, 'g'), '')
+      .replace( new RegExp( `\\[${ tag }\\][\\s\\S]*$`, 'g'), '')
+  return out.replace( /\n{3,}/g, '\n\n').trim()
+}
+
 /**
  * Parse tagged JSON blocks from the reasoning text.
  * The LLM embeds optional outputs as [TAG]...[/TAG] blocks.
@@ -193,6 +250,7 @@ function parseTaggedBlocks(
     'GOALS_REPRIORITIZE',
     'EFFECTORS',
     'SELF_OBS',
+    'SKILLS',
   ],
   found = taggedTypes.filter( t => text.includes(`[${t}]`) )
   if( found.length > 0 ){
@@ -299,6 +357,13 @@ function parseTaggedBlocks(
   }
   catch { /* ignore */ }
 
+  // Named compound skills — the creation seam for learned composites (#114).
+  try {
+    const skillsData = parseJsonBlock('SKILLS') as { newSkills?: ExecutiveOutputFull['newSkills'] } | null
+    if( skillsData?.newSkills ) full.newSkills = skillsData.newSkills
+  }
+  catch { /* ignore */ }
+
   // [ACK] and legacy [REPLY] blocks are no longer emitted by any engine.
   // [ACK]   — removed with the legacy master communication path (Phase 13.8).
   // [REPLY] — replaced by [REPLY_TEXT] plain-text block in conversation facets.
@@ -319,7 +384,15 @@ function extractBlock( text: string, tag: string ): string | null {
  * Used for [REPLY_TEXT] — content is streamed directly to the client,
  * so it must be clean prose, not a JSON payload.
  */
-function extractTextBlock( text: string, tag: string ): string | null {
+/**
+ * Pull one plain-text block out of a response.
+ *
+ * Exported for the guard: this slice is where a stray marker survives into
+ * content, and the seam is the thing worth testing. `parseResponse` needs a full
+ * well-formed response around it, which is exactly the setup that hides a defect
+ * living in one line of string handling.
+ */
+export function extractTextBlock( text: string, tag: string ): string | null {
   const open  = `[${tag}]`
   const close = `[/${tag}]`
   const openIdx  = text.indexOf( open )
@@ -330,51 +403,60 @@ function extractTextBlock( text: string, tag: string ): string | null {
     ? text.slice( contentStart, closeIdx )
     : text.slice( contentStart )   // unclosed block — take everything after the open marker
 
-  return content.trim() || null
+  // A stray marker INSIDE the body survives this slice — the block runs from the
+  // first open to the first close after it, and anything between is content by
+  // construction. Live, a reply went out as four substantive bubbles and a fifth
+  // reading exactly `[REPLY_TEXT]`: the person received a message whose whole
+  // content was the name of the slot it should have filled.
+  return stripProtocolMarkers( content ) || null
 }
 
 /**
- * Build a heuristic fallback output when LLM response parsing fails.
- * Chooses actions based on current physiological state.
+ * What the executive intends when its own reasoning did not come back.
+ *
+ * Two things had to change here. Every action this produced was PROSE, not a
+ * schema: `observe`, `replenish energy`, `enter deep rest to reduce fatigue`,
+ * `calm my mind and reduce tension`, `explore`, `learn`, `express_emotion`.
+ * Only `rest` names anything the body can enact. The rest reach the agency, fail
+ * to resolve, and become an ideomotor push toward an act that does not exist —
+ * observed live as `master decided [observe] conf=0.4` four times across two
+ * boots, each one a decision that could go nowhere.
+ *
+ * And the "no urgent need" branch was INVENTION. The executive could not read
+ * its own thought, so it made one up and pushed it into the field as intention.
+ * That is the mind being told what it wants. The substrate does not need the
+ * help: the affordance field is always there, System 1 selects from it every
+ * tick without an executive, and it now carries real satiation — the monotony
+ * this used to break by cycling a hardcoded list is handled where monotony
+ * actually lives.
+ *
+ * So: reflexes stay, invention goes. Critically low energy, high sleep pressure
+ * or high stress still push a real regulatory stance, because a body in trouble
+ * should not depend on an LLM parsing correctly. Anything else yields NO action
+ * and lets the substrate decide, which is what it is for.
  */
 export function buildFallbackOutput(
   state: ReadonlySimulationState,
-  recentActionTypes: string[]
+  _recentActionTypes: string[]
 ): ExecutiveOutputFull {
-  const energy = state.metrics.get('energy.level') ?? 100
+  const energy        = state.metrics.get('energy.level')  ?? 100
   const sleepPressure = state.metrics.get('sleep.pressure') ?? 0
-  const stressLoad = state.metrics.get('stress.load') ?? 0
-
-  let actionType = 'observe'
-  let actionReason = 'No urgent needs — observing surroundings.'
+  const stressLoad    = state.metrics.get('stress.load')    ?? 0
 
-  if( energy < 20 ){
-    actionType = 'replenish energy'
-    actionReason = 'Energy critically low — attempting to rest.'
-  }
-  else if( sleepPressure > 60 ){
-    actionType = 'enter deep rest to reduce fatigue'
-    actionReason = 'Sleep pressure high — attempting to sleep.'
-  }
-  else if( stressLoad > 70 ){
-    actionType = 'calm my mind and reduce tension'
-    actionReason = 'Stress elevated — attempting to meditate.'
-  }
-  else {
-    // Vary the fallback when low-effort actions have dominated recently
-    const monotonous = recentActionTypes.filter( t => t === 'reflect' || t === 'observe').length >= 3
-    if( monotonous) {
-      const alternatives = ['explore', 'learn', 'express_emotion', 'rest']
-      const tick = state.tick as number
-
-      actionType = alternatives[ tick % alternatives.length ]!
-      actionReason = 'Breaking monotony — choosing a varied action during LLM fallback.'
-    }
-  }
+  // Innate stances only — what the body can actually enact.
+  const reflex: { type: string; reasoning: string } | null =
+      energy < 20        ? { type: 'rest',     reasoning: 'Energy critically low — I let myself recover.' }
+    : sleepPressure > 60 ? { type: 'rest',     reasoning: 'Sleep pressure high — I let myself recover.' }
+    : stressLoad > 70    ? { type: 'withdraw', reasoning: 'Stress elevated — I pull back from the press of things.' }
+    : null
 
   return {
-    actions: [{ type: actionType, reasoning: actionReason, expectedOutcome: 'State improves' }],
-    reasoning: `Heuristic fallback — LLM unavailable. ${actionReason}`,
+    actions: reflex
+      ? [ { type: reflex.type, reasoning: reflex.reasoning, expectedOutcome: 'The body settles' } ]
+      : [],
+    reasoning: reflex
+      ? `Heuristic fallback — my reasoning did not come back. ${ reflex.reasoning }`
+      : 'Heuristic fallback — my reasoning did not come back, and nothing about my state is pressing. I intend nothing in particular; my body goes on choosing.',
     confidence: 0.4
   }
 }