@mindot/will 0.7.0 → 0.9.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 },
+        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: [],
@@ -465,11 +512,20 @@ export class ExecutiveFacet {
       // Use streaming call when a per-facet chunk handler is registered —
       // this enables entity-scoped token delivery (e.g. AuditionEngine SSE).
       // Falls back to regular call when no handler is present.
+      // MODEL_ROUTING W0 — same effort gate as master, so a facet's demand is
+      // measured on the identical scale (a live message awaiting reply is this
+      // focus's stakes-bearing moment, and already weighs into the score).
       const facetMeta: LLMCallMeta = {
         category:  'executive',
         attribute: 'facet',
-        function:  this._currentFocus?.function ?? '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:  reportFocus.function ?? '-',
         scope:     this.facetId,
+        demand:    processSelection.effortScore,
       }
       const result = this._chunkHandler
         ? await this._llmDirector.callStream( systemPrompt, userMessage, currentState.tick, this._chunkHandler, undefined, facetMeta )
@@ -547,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
@@ -558,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}`,
@@ -579,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
@@ -587,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}`,
@@ -605,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 } from '#llm/wire.contracts'
 import type { ReadonlySimulationState } from '#core/types'
 import type { ExecutiveOutputFull, ExecutiveOutputMinimal, IdeationCandidate, IdeationOutput } from '#faculties/executive.engine/types'
 
@@ -68,6 +68,18 @@ export function parseResponse(
   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
 }
 
@@ -193,6 +205,7 @@ function parseTaggedBlocks(
     'GOALS_REPRIORITIZE',
     'EFFECTORS',
     'SELF_OBS',
+    'SKILLS',
   ],
   found = taggedTypes.filter( t => text.includes(`[${t}]`) )
   if( found.length > 0 ){
@@ -299,6 +312,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.