@mindot/will 0.9.0 → 0.10.0

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

@@ -18,6 +18,7 @@
  */
 
 import { logger } from '#core/logger'
+import { readAliases, canonicalOf } from '#cognition/social.identity'
 import type { SessionLogger } from '#stem/tracts/session.logger'
 import type {
   Tick,
@@ -28,6 +29,9 @@ import type {
   EntityInput
 } from '#core/types'
 import { AsyncEngine } from '#core/async.engine'
+import {
+  actionRecordEntity, staleActionRecordIds, type ActionStatus,
+} from '#faculties/executive.engine/action.record'
 import type { IntermediateStream } from '#core/async.engine'
 import type { WorkingMemory } from '#faculties/working.memory'
 import type { GoalManager, GoalState } from '#faculties/goal.manager'
@@ -84,8 +88,6 @@ import type { EngineResult } from '#core/orchestrator'
 import type { Duration } from '#core/types'
 import { wallClock } from '#core/wall.clock'
 
-// Re-export for compatibility
-export { ExecutiveFacet, type ExecutiveFacetHandle }
 
 /**
  * How hard a reasoning facet pulls on attention, as an `attention.demand` urgency.
@@ -199,13 +201,39 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
   private readonly _facetSupervisor = new FacetSupervisor()
 
   /**
-   * Who each live facet is engaged with, learned from `executive.facet.sync`.
-   * Keyed by facetId; the last sync wins. Rendered into the master's own prompt so
-   * the singular seat can reason across its conversations "as if they were sitting
-   * at the same table" — which it cannot do while it only knows facet numbers.
-   * Stale entries age out on read (see _activeConversations).
+   * Who each live facet is engaged with AND what it concluded there, learned from
+   * `executive.facet.sync`. Keyed by facetId; the last sync wins. Rendered into
+   * the master's own prompt so the singular seat can reason across its
+   * conversations "as if they were sitting at the same table" — which it cannot
+   * do while it only knows facet numbers. Stale entries age out on read (see
+   * _activeConversations).
+   *
+   * `concluded` IS THE RETURN LEG, and it did not exist. `executive.facet.sync`
+   * has always carried the facet's full `reasoning`; this handler received it and
+   * dropped it on the floor. So the sync was one-way: the master's thinking flows
+   * DOWN to facets as "What I've Been Turning Over", while what a facet worked out
+   * came back as identity and a salience spike — that attention had been engaged,
+   * and with whom, never what it concluded.
+   *
+   * A facet is the same mind with a focus, not a subordinate reporting in. A mind
+   * that cannot read back its own thinking from where its attention has been is
+   * split, and the prompt comment two files over already named the consequence:
+   * "telling one person it has contacted another when it has not".
+   *
+   * It is kept HERE, on the engine, rather than as a percept, because a percept is
+   * swept after 2 ticks and a working-memory item decays below the retrieval
+   * threshold in about 9 — while the master's own interval is 15. Anything routed
+   * that way is usually gone before the master next reads. This survives to the
+   * next cycle by construction.
    */
-  private _facetSubjects = new Map<string, { entityId: string; name?: string; tick: number }>()
+  private _facetSubjects = new Map<string, {
+    entityId:   string
+    name?:      string
+    tick:       number
+    concluded?: string
+    /** Commitments the facet declared toward a THIRD party while attending here. */
+    promised?:  Array<{ what: string; target?: string; gist?: string; tick: number }>
+  }>()
 
   // ── Cognitive models ───────────────────────────────────────
   private readonly _model = new GenerativeModel()
@@ -247,6 +275,11 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
   // See EscalationBuffer for the full rationale (R5-g-2).
   private readonly _escalations = new EscalationBuffer()
 
+  /** First tick of an unbroken `hasPendingWork` suppression; null when the seat is free. */
+  private _mutedSince: Tick | null = null
+  /** Whether this suppression episode has already been reported. */
+  private _mutedWarned = false
+
   /** Set/clear the chunk broadcaster (called by WillManager when SSE clients connect). */
   setChunkBroadcaster( fn: (( chunk: string ) => void) | null ): void {
     this._chunkBroadcaster = fn
@@ -446,7 +479,7 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     // attachments. The supervisor owns the registry + attention budget and
     // performs the throw-checks on bus / director / state ref.
     return this._facetSupervisor.spawn( {
-      ...( key ? { key } : {} ),
+      ...( key ? { key: this._canonicalKey( key ) } : {} ),
       bus:         this._bus,
       llmDirector: this._llmDirector,
       stateRef:    this._lastStateRef,
@@ -469,7 +502,45 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
    * See FacetSupervisor.handleFor.
    */
   facetFor( key: string ): ExecutiveFacetHandle | undefined {
-    return this._facetSupervisor.handleFor( key )
+    // Tolerant of BOTH id spaces, canonical first.
+    //
+    // A facet registered before its anchor was visible is still that person's
+    // open thread, and answering "nobody home" would open a second one beside it
+    // — the exact failure this key exists to prevent. Two ways that happens: a
+    // first message racing the tracker's mint, and a later name-merge that
+    // re-points one anchor onto another (KNOWN_ENTITY Phase 5, which is
+    // deliberately revisable and never destructively re-keys).
+    return this._facetSupervisor.handleFor( this._canonicalKey( key ) )
+        ?? this._facetSupervisor.handleFor( key )
+  }
+
+  /**
+   * A facet key in the PERSON's id space, not the address's.
+   *
+   * `FacetSpawnDeps.key` is `<role>:<entityId>`, and the two sides of that
+   * contract disagreed about which space `entityId` lives in. Audition spawns a
+   * conversation facet keyed by `percept.speakerEntityId` — the transport address
+   * the message arrived on (`discord:1019…`) — while `authorOutreach` asks for
+   * `conversation:<anchor>` (`ke:1sqlkux`), because the executive resolves a
+   * person to their anchor before willing anything at them.
+   *
+   * So the dedup this key exists for never fired for a master-willed outreach.
+   * Every one spawned a transient rival facet on someone the mind was already
+   * talking to — which is what the key was added to prevent, and what its own
+   * comment claims it does. Observed live: a reply and an unprompted second
+   * answer to the same question 27 seconds apart, the second composed by a facet
+   * that could not see the first.
+   *
+   * Safe to resolve here because KnownEntityTracker mints the anchor on FIRST
+   * sight of an address, deterministically from it (R2), so a conversation is
+   * keyed the same way from its first message onward.
+   */
+  private _canonicalKey( key: string ): string {
+    const cut = key.indexOf(':')
+    if( cut < 0 || !this._lastStateRef ) return key
+    const id    = key.slice( cut + 1 )
+    const canon = canonicalOf( readAliases( this._lastStateRef.entities ), id )
+    return canon === id ? key : `${ key.slice( 0, cut ) }:${ canon }`
   }
 
   // ── CognitiveEngine interface ──────────────────────────────
@@ -477,6 +548,49 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
   subscribes(): string[] { return [ '*' ] }
   publishes(): CognitiveEventSchema[] { return [] }
 
+  /**
+   * Fold one resolved act into the mind's record of its own doing.
+   *
+   * `withheld` is kept distinct from `failed` deliberately: the mind formed the
+   * act and chose not to complete it, which is a judgement, not an inability.
+   * Collapsing them is the #123 mistake — a COO learning it was bad at speaking
+   * from the times it decided not to speak.
+   */
+  private _recordAction( event: CognitiveEvent ): StateCommands | void {
+    const p = event.payload as {
+      actionType?: unknown; success?: unknown; targetEntityId?: unknown
+      description?: unknown; planId?: unknown; tick?: unknown
+    } | undefined
+    const type = typeof p?.actionType === 'string' ? p.actionType : undefined
+    if( !type ) return
+
+    const status: ActionStatus = event.type === 'action.withheld' ? 'withheld'
+      : p?.success === false ? 'failed'
+      : 'completed'
+
+    const record = actionRecordEntity({
+      type, status,
+      tick: typeof p?.tick === 'number' ? p.tick : 0,
+      ...( typeof p?.targetEntityId === 'string' ? { targetEntityId: p.targetEntityId } : {} ),
+      // WHOLE. 120 here, 300 at the session log and 700 at the MCP boundary were
+      // three unexamined numbers cutting the same string, and the cut was the
+      // engine deciding how much of what a host said the mind was allowed to
+      // keep. What a host sends is consumed in its entirety; what the engine
+      // itself composes it may bound (see `PERCEPT_SUMMARY_CAP`), because there
+      // it is not destroying anyone's only copy.
+      //
+      // Safe to leave unbounded only because P2 split fate from facts: this
+      // carries a FATE, which is short by nature. The answer to a lookup leaves
+      // through `observation` and reaches the mind as a percept.
+      outcome: typeof p?.description === 'string' ? p.description : '',
+      ...( typeof p?.planId === 'string' ? { planId: p.planId } : {} ),
+    })
+
+    // Pruning happens in `react`, which has frozen state to prune against; an
+    // event handler sees only the event.
+    return { set: [ record ] }
+  }
+
   snapshot(): Record<string, unknown> {
     return {
       bufferSize: this._gatingState.salienceBuffer.length,
@@ -488,6 +602,24 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
   onCognitiveEvent( event: CognitiveEvent ): StateCommands | void {
     if( event.sourceEngine === this.name ) return
 
+    // What became of what I did.
+    //
+    // the outcomes section has existed — section, builder and type —
+    // since it was written, fed by `context.ts` scanning `decision.record` for
+    // an `actionStatus` that nothing in the engine has ever set. It rendered 0
+    // times across every prompt a live COO received. So the mind could see what
+    // it had SAID and never what it had DONE, and its only other record of
+    // acting is `## Recent Actions`, which is built from the executive's own
+    // DECISIONS. A record of acting that contains only intentions cannot
+    // distinguish an intention from an act — and one did not, reporting a spec
+    // as drafted and sent when it had no effectors and had sent nothing.
+    //
+    // Written here because these events already arrive here (`subscribes()` is
+    // `['*']`) and the returned commands are drained onto state by the
+    // orchestrator. See `action.record.ts`.
+    if( event.type === 'action.outcome' || event.type === 'action.withheld')
+      return this._recordAction( event )
+
     // Spare attention scales the facet allowance within the persona's ceiling.
     if( event.type === 'attention.state.changed'){
       const p = event.payload as { freeFraction: number }
@@ -553,6 +685,14 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
       result.commands.delete = [ ...( result.commands.delete ?? [] ), ...focus.delete ]
     }
 
+    // Hold as many acts as the prompt shows and no more. Done here rather than
+    // in the event handler because pruning needs frozen state to prune against.
+    const stale = staleActionRecordIds( state.entities as never )
+    if( stale.length > 0 ){
+      result.commands ??= {}
+      result.commands.delete = [ ...( result.commands.delete ?? [] ), ...stale ]
+    }
+
     return result
   }
 
@@ -677,6 +817,26 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     // Always update counters, even when not activating
     updateGatingState( this._gatingState, state, tick, result.shouldActivate, result.cleanedBuffer )
 
+    // A reasoning pass that never settles holds this gate shut until the
+    // AsyncEngine's stale prune drops it 600 ticks later, and every one of those
+    // ticks was silent — the mind simply stopped deliberating and nothing said
+    // why. Warn ONCE, at the point a pass has outlived any healthy one; warning
+    // every tick would bury the line it exists to surface.
+    if( result.reason === 'hasPendingWork'){
+      this._mutedSince ??= tick
+      // Once per episode, not once at an exact tick: react() is not guaranteed to
+      // be called on every tick, and an `=== threshold` test that the clock steps
+      // over never fires at all — a silent warning about a silence.
+      if( !this._mutedWarned && tick - this._mutedSince >= this._executiveInterval * 3 ){
+        this._mutedWarned = true
+        logger.warn(
+          `[executive] no cycle for ${ tick - this._mutedSince } ticks — a reasoning pass ` +
+          `has not settled and is holding the seat (tick=${tick})`
+        )
+      }
+    }
+    else { this._mutedSince = null; this._mutedWarned = false }
+
     if( result.shouldActivate )
       logger.info(`[executive] activating — reason: ${result.reason} (tick=${tick})`)
 
@@ -991,11 +1151,6 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
       plansCount: executiveOutput.plans?.length ?? 0,
       goalsNew: executiveOutput.newGoals ?? [],
       goalsAbandon: executiveOutput.goalsToAbandon ?? [],
-      replies: ( executiveOutput.conversationReplies ?? [] ).map( r => ( {
-        targetEntityId: r.targetEntityId,
-        targetEntityName: r.targetEntityName,
-        messages: r.messages,
-      } ) ),
       hasIntrospection: !!executiveOutput.introspection,
       hasNarrative: !!executiveOutput.narrative
     } )
@@ -1191,16 +1346,17 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
 
     // Clear processed messages
 
-    // Merge escalation percepts into final commands, and retire the ones already
-    // honoured. See _dischargedUndertakings for why this is not optional.
-    const { keep, discharge } = this._reconcileUndertakings( escalationPercepts, this._lastStateRef! )
-    if( keep.length ){
+    // Merge escalation percepts into the final commands.
+    //
+    // `_reconcileUndertakings` used to sit here, discharging promises the engine
+    // judged kept and dropping restatements. Both are gone with the undertaking
+    // harness: a promise is no longer a percept, so there is nothing to
+    // reconcile. What the facet declared rides the sync tract to the master's own
+    // prompt, and what to do about it — including whether it is still worth
+    // doing — is the mind's, through the goal machinery it already has.
+    if( escalationPercepts.length ){
       commands.set ??= []
-      commands.set.push( ...keep )
-    }
-    if( discharge.length ){
-      commands.delete ??= []
-      commands.delete.push( ...discharge )
+      commands.set.push( ...escalationPercepts )
     }
 
     // ── Persist deliberation cache (mirrors the rolling summary) ──
@@ -1271,7 +1427,13 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
 
     return [ ...this._facetSubjects.values() ]
       .sort( ( a, b ) => b.tick - a.tick )
-      .map( s => ({ entityId: s.entityId, ...( s.name ? { name: s.name } : {} ), sinceTick: s.tick }) )
+      .map( s => ({
+        entityId: s.entityId,
+        ...( s.name ? { name: s.name } : {} ),
+        sinceTick: s.tick,
+        ...( s.concluded ? { concluded: s.concluded } : {} ),
+        ...( s.promised?.length ? { promised: s.promised } : {} ),
+      }) )
   }
 
   /**
@@ -1311,76 +1473,6 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
    * claim that the words are unsent; whether to say more to that person is then an
    * ordinary competition like any other.
    */
-  private _reconcileUndertakings(
-    incoming: EntityInput[],
-    state:    ReadonlySimulationState,
-  ): { keep: EntityInput[]; discharge: string[] } {
-    /** Latest tick at which anything was sent to each target. */
-    const contacted = new Map<string, number>()
-    for( const [ , e ] of state.entities ){
-      if( e.type !== 'conversation.sent') continue
-      const m      = e.metadata as Record<string, unknown> | undefined
-      const target = typeof m?.['targetEntityId'] === 'string' ? m['targetEntityId'] as string : undefined
-      if( !target ) continue
-      // metadata.tick where set, else the entity's own sim-clock tick. Reading
-      // metadata alone defaulted every record to 0, so `contacted >= madeAt` was
-      // false for any promise made after tick 0 — this discharge never once fired.
-      const at = typeof m?.['tick'] === 'number' ? m['tick'] as number
-               : typeof ( e as { tick?: number } ).tick === 'number' ? ( e as { tick?: number } ).tick as number
-               : 0
-      contacted.set( target, Math.max( contacted.get( target ) ?? 0, at ) )
-    }
-
-    /** An undertaking is spent once we have reached its target since making it. */
-    const honoured = ( target: string | undefined, madeAt: number ): boolean =>
-      !!target && ( contacted.get( target ) ?? -1 ) >= madeAt
-
-    const undertakingOf = ( m: Record<string, unknown> | undefined ) =>
-      m?.['category'] === 'undertaking'
-        ? {
-          target: typeof m['undertakingTarget'] === 'string' ? m['undertakingTarget'] as string : undefined,
-          madeAt: typeof m['tick'] === 'number' ? m['tick'] as number : 0,
-        }
-        : undefined
-
-    const discharge: string[] = []
-    /** Targets we are already carrying a live, unhonoured undertaking toward. */
-    const carrying = new Set<string>()
-
-    for( const [ id, e ] of state.entities ){
-      if( e.type !== 'percept') continue
-      const u = undertakingOf( e.metadata as Record<string, unknown> | undefined )
-      if( !u ) continue
-
-      // No target ⇒ it predates the field this reconciliation keys on, so it can
-      // never be matched against a contact and would assert "nothing has gone to
-      // them yet" for the rest of the mind's life. Seven of these were found in a
-      // live snapshot, each one re-read every cycle. Undischargeable is strictly
-      // worse than gone.
-      if( !u.target ){ discharge.push( id ); continue }
-
-      if( honoured( u.target, u.madeAt ) ) discharge.push( id )
-      else carrying.add( u.target )
-    }
-
-    // Drop an incoming restatement of something already honoured or already held.
-    // Duplicates were how seven of these piled up: each master cycle drained a
-    // fresh copy of a promise that could never be marked kept.
-    const keep = incoming.filter( p => {
-      const u = undertakingOf( p.metadata as Record<string, unknown> | undefined )
-      if( !u?.target ) return true
-      if( honoured( u.target, u.madeAt ) ) return false
-      if( carrying.has( u.target ) ) return false
-      carrying.add( u.target )
-      return true
-    } )
-
-    if( discharge.length )
-      logger.info(`[executive] ${ discharge.length } undertaking(s) discharged — the contact was made`)
-
-    return { keep, discharge }
-  }
-
   private _onFacetSync( event: CognitiveEvent ): void {
     const payload = event.payload as {
       facetId?: string
@@ -1391,13 +1483,28 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
       subjectName?: string
     }
 
-    // Remember WHO this facet is with, not just that it reported.
-    if( payload.facetId && payload.subjectEntityId )
+    // Remember WHO this facet is with, and WHAT it worked out there. The second
+    // half is the return leg: `reasoning` has always been on this payload and was
+    // read into a local and then dropped, so the master learned that its attention
+    // had been engaged and never what it concluded.
+    //
+    // Carried whole, not clipped. For the master this is the only copy — the
+    // facet's own history is in the facet, and once that conversation ends the
+    // thinking is gone. Live facets are few (one per open conversation), so this
+    // is bounded by how many people the mind is talking to, not by traffic.
+    if( payload.facetId && payload.subjectEntityId ){
+      const prior = this._facetSubjects.get( payload.facetId )
       this._facetSubjects.set( payload.facetId, {
         entityId: payload.subjectEntityId,
         ...( payload.subjectName ? { name: payload.subjectName } : {} ),
         tick: payload.tick ?? this._lastExecutiveTick ?? 0,
+        ...( payload.reasoning ? { concluded: payload.reasoning } : {} ),
+        // Promises ride along rather than being re-derived: a commitment the facet
+        // DECLARED is a fact, while the same thing read back out of prose is a
+        // guess. Preserved across syncs until the master has read them.
+        ...( prior?.promised?.length ? { promised: prior.promised } : {} ),
       })
+    }
 
     // Unconditional (not gated on WORKSPACE_THRESHOLD like ordinary traffic):
     // a facet reporting back is the master's own attention returning, and the
@@ -1461,31 +1568,81 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     // unfalsifiable: it could be marked kept by something that happened first.
     const tick = payload.tick ?? this._currentTick
 
+    // AN UNDERTAKING RIDES THE TRACT, NOT A HARNESS OF ITS OWN.
+    //
+    // It used to become a percept plus a standing ideomotor intent plus a bespoke
+    // discharge rule — the engine deciding how hard a promise pulls and when it
+    // counts as kept. That is judgement, and judgement is the mind's. What is not
+    // the mind's to supply is the FACT crossing from where its attention was to
+    // where its singular seat is; that crossing is anatomy.
+    //
+    // So it is filed with what the facet concluded and rendered to the master at
+    // its next cycle. Reading that it promised someone something and has not done
+    // it, the master may form a goal — which it can already do, and which the goal
+    // machinery then lifts, plans and completes. Or it may not, and that is a
+    // decision rather than a mechanism failing.
+    //
+    // The old route could not have worked anyway: a percept is swept at +2 ticks
+    // and decays out of working memory at about +9, while the master's interval
+    // is 15. The notice was usually gone before the seat it was addressed to ran.
+    // Spike the salience buffer FIRST, for both kinds. The master must NOT be
+    // handed the inbound as a message to answer — that would make it produce a
+    // [REPLY], duplicating the facet's and breaking the facet/master boundary.
+    // (The queue that once carried inbound this way was removed in #114: nothing
+    // ever filled it.) Done before the undertaking branch returns, so a promise
+    // still pulls the master's next cycle forward rather than waiting out the
+    // interval — which matters more now that the promise is what it will read.
+    this._gatingState.salienceBuffer.push({ event, tick })
+
+    const from = payload.subjectName ?? payload.subjectEntityId ?? payload.facetId ?? 'a focus'
+
+    if( payload.body.kind === 'undertaking'){
+      const body = payload.body
+      // Keyed by facet because that is what the master's view of its open threads
+      // is keyed by. A handoff with no facet id has nowhere to file — say so
+      // rather than dropping it quietly, which is how a promise disappears with
+      // nobody able to tell whether it was ever made.
+      if( !payload.facetId ){
+        logger.warn(`[executive] commitment "${ body.what }" arrived with no facetId — nowhere to file it`)
+        return
+      }
+      // Created if absent: a facet can hand something up before its first sync,
+      // and requiring the entry to exist first made that promise vanish.
+      const at = this._facetSubjects.get( payload.facetId ) ?? {
+        entityId: payload.subjectEntityId ?? payload.facetId,
+        ...( payload.subjectName ? { name: payload.subjectName } : {} ),
+        tick,
+      }
+      at.promised = [
+        // Deduped on WHAT was promised, falling back to the target when two
+        // wordings mean the same contact: restating a promise is the same
+        // promise, and the master does not need telling twice.
+        ...( at.promised ?? [] ).filter( p =>
+          p.what !== body.what && !( body.target !== undefined && p.target === body.target ) ),
+        { what: body.what,
+          ...( body.target ? { target: body.target } : {} ),
+          ...( body.gist   ? { gist:   body.gist   } : {} ), tick },
+      ]
+      this._facetSubjects.set( payload.facetId, at )
+      logger.info(
+        `[executive] filed commitment from ${from} → "${ body.what }" ` +
+        `(it reads this at its next cycle; what to do about it is its own call)`
+      )
+      return
+    }
+
     this._escalations.push({
       tick,
       ...( payload.facetId         ? { facetId:         payload.facetId }         : {} ),
       ...( payload.subjectEntityId ? { subjectEntityId: payload.subjectEntityId } : {} ),
       ...( payload.subjectName     ? { subjectName:     payload.subjectName }     : {} ),
       ...( payload.threadId        ? { threadId:        payload.threadId }        : {} ),
-      body: payload.body.kind === 'undertaking'
-        ? { ...payload.body, reasoning: ( payload.body.reasoning ?? '').slice( 0, 400 ) }
-        : { ...payload.body, reasoning: ( payload.body.reasoning ?? '').slice( 0, 400 ) },
+      body: { ...payload.body, reasoning: ( payload.body.reasoning ?? '').slice( 0, 400 ) },
     })
 
-    // Spike the salience buffer so the master fires soon rather than waiting for
-    // the next scheduled interval. The master must NOT be handed the inbound as a
-    // message to answer — that would make it produce a [REPLY], duplicating the
-    // facet's and breaking the facet/master boundary. (The queue that once carried
-    // inbound this way was removed in #114: nothing ever filled it.)
-    this._gatingState.salienceBuffer.push({ event, tick })
-
-    const from = payload.subjectName ?? payload.subjectEntityId ?? payload.facetId ?? 'a focus'
     logger.info(
-      payload.body.kind === 'undertaking'
-        ? `[executive] master queued undertaking from ${from} ` +
-          `→ reach ${payload.body.target} (confidence=${payload.confidence?.toFixed( 2 )})`
-        : `[executive] master queued escalation percept from ${from} ` +
-          `(confidence=${payload.confidence?.toFixed( 2 )})`
+      `[executive] master queued escalation percept from ${from} ` +
+      `(confidence=${payload.confidence?.toFixed( 2 )})`
     )
   }