@mindot/will 0.1.1 → 0.2.0

package/package.json

@@ -1,21 +1,47 @@
 {
   "name": "@mindot/will",
-  "version": "0.1.1",
-  "description": "Will — an engine for persistent machine minds. A Will is a continuously-ticking synthetic mind built from 38 cognitive faculties, a learning agency pipeline, and a dual-process executive — deterministic, persistent, and portable (PMA).",
+  "version": "0.2.0",
   "author": "Fabrice <fabrice8@github.com>",
-  "license": "Apache-2.0",
-  "packageManager": "bun@1.3.9",
-  "engines": {
-    "bun": ">=1.0.0"
-  },
-  "homepage": "https://github.com/mindot-ai/will#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mindot-ai/will.git"
   },
+  "bin": {
+    "will": "dist/mcp/cli.js"
+  },
+  "main": "./dist/index.js",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.5"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.0.0"
+  },
+  "optionalDependencies": {
+    "socket.io-client": "^4.8.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./mcp": {
+      "import": "./dist/mcp/effectors.js",
+      "types": "./dist/mcp/effectors.d.ts"
+    }
+  },
   "bugs": {
     "url": "https://github.com/mindot-ai/will/issues"
   },
+  "description": "Will — an engine for persistent machine minds. A Will is a continuously-ticking synthetic mind built from 38 cognitive faculties, a learning agency pipeline, and a dual-process executive — deterministic, persistent, and portable (PMA).",
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "files": ["dist", "src"],
+  "homepage": "https://github.com/mindot-ai/will#readme",
   "keywords": [
     "ai",
     "agent",
@@ -30,19 +56,11 @@
     "mind",
     "deterministic"
   ],
+  "license": "Apache-2.0",
+  "packageManager": "bun@1.3.9",
   "publishConfig": {
     "access": "public"
   },
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": ["dist", "src"],
   "scripts": {
     "build": "tsup",
     "build:types": "tsc --project tsconfig.build.json",
@@ -58,16 +76,6 @@
     "test:watch": "vitest watch",
     "test:integration": "vitest run src/tests/integration"
   },
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.1048.0"
-  },
-  "optionalDependencies": {
-    "socket.io-client": "^4.8.1"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.0",
-    "vitest": "^4.1.5"
-  }
+  "type": "module",
+  "types": "./dist/index.d.ts"
 }

package/src/cognition/agency/engines/action.selector.ts

@@ -293,6 +293,9 @@ export class ActionSelector implements CognitiveEngine {
               targetEntityId: s.affordance.targetEntityId,
               parameters:     s.affordance.parameters,
               activation:     s.activation,
+              // Carry the ability's meaning so the Deliberator weighs what each
+              // option is FOR, not bare labels.
+              ...( s.affordance.description ? { description: s.affordance.description } : {} ),
               // Channel B: flag a candidate that is an active plan's frontier step, so
               // the deliberation facet can own "this is my plan's next step" in-character.
               ...( s.affordance.source === 'plan' ? { fromPlan: true } : {} ),

package/src/cognition/agency/engines/affordance.synthesizer.ts

@@ -149,24 +149,36 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         })
       }
 
-    const entitySchema = schemas.find( s => s.binds === 'entity' )
-    if( entitySchema )
+    // Target-bound schemas are bound against each perceived known-entity of the
+    // matching kind: `binds: 'entity'` schemas (innate `reach-out` + host
+    // person-effectors) to sentient entities, `binds: 'object'` schemas to
+    // things — so the Will can direct `give`/`greet` at someone or `use`/`pick-up`
+    // at something in particular. Each (schema × target) enters as a candidate at
+    // the target's salience and competes through the attention cap.
+    const personSchemas = schemas.filter( s => s.binds === 'entity' )
+    const objectSchemas = schemas.filter( s => s.binds === 'object' )
+    if( personSchemas.length > 0 || objectSchemas.length > 0 )
       for( const [ id, e ] of state.entities ){
         if( e.type !== 'known-entity' ) continue
-        const m = e.metadata
-        if( str( m?.['kind'] ) !== 'sentient' ) continue
+        const m    = e.metadata
+        const kind = str( m?.['kind'] )
+        const applicable = kind === 'sentient' ? personSchemas : kind === 'thing' ? objectSchemas : null
+        if( !applicable || applicable.length === 0 ) continue
         const keid = str( m?.['keid'] ) ?? id
         const fam  = num( m?.['familiarity'], 0 )
         const val  = num( m?.['valence'], 0 )
         const res  = num( m?.['resolutionConfidence'], 0 )
-        candidates.push({
-          salience: fam * 0.6 + Math.max( 0, val ) * 0.3 + res * 0.1 + ( goalTargets.get( keid ) ?? 0 ),
-          affordance: this._build( entitySchema, tick, state, valence, energyLow, skills, {
-            evokedBy:       id,
-            targetEntityId: keid,
-            parameters:     { targetEntityName: str( m?.['name'] ) ?? keid },
-          } ),
-        })
+        const salience = fam * 0.6 + Math.max( 0, val ) * 0.3 + res * 0.1 + ( goalTargets.get( keid ) ?? 0 )
+        const name     = str( m?.['name'] ) ?? keid
+        for( const schema of applicable )
+          candidates.push({
+            salience,
+            affordance: this._build( schema, tick, state, valence, energyLow, skills, {
+              evokedBy:       id,
+              targetEntityId: keid,
+              parameters:     { targetEntityName: name },
+            } ),
+          })
       }
 
     // ── ideomotor candidates: the executive's imagined actions, pre-activated ──
@@ -310,6 +322,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       habitStrength,
       available:       this._available( schema.preconditions, ( k ) => metric( state, k, 0 ) ),
       tags:            schema.tags ?? [],
+      ...( schema.description ? { description: schema.description } : {} ),
       planBias:        ctx.planBias,
       planId:          ctx.planId,
       stepId:          ctx.stepId,
@@ -333,6 +346,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         habitStrength:   a.habitStrength,
         available:       a.available,
         tags:            a.tags,
+        description:     a.description,
         planBias:        a.planBias,
         planId:          a.planId,
         stepId:          a.stepId,

package/src/cognition/agency/engines/deliberation.engine.ts

@@ -50,6 +50,8 @@ interface Candidate {
   targetEntityId?: string
   parameters?:     Record<string, unknown>
   activation?:     number
+  /** The ability's declared meaning (external effectors) — what it is for. */
+  description?:    string
   /** Channel B: this candidate is an active plan's current frontier step. */
   fromPlan?:       boolean
 }
@@ -212,10 +214,13 @@ export class DeliberationEngine implements CognitiveEngine {
       lines.push( 'Your automatic action-selection was uncertain. Candidate actions:' )
     candidates.forEach( ( c, i ) => {
       const to   = c.targetEntityId ? ` toward ${ c.targetEntityId }` : ''
+      // The ability's meaning, so the facet weighs what each option IS FOR rather
+      // than choosing among bare labels ("give" vs "attack" is a real difference).
+      const what = c.description ? ` — ${ c.description }` : ''
       // Channel B: name the plan link so the facet chooses as the self pursuing it,
       // not blindly among labels ("this one is the next step of the plan I'm on").
-      const plan = c.fromPlan ? " — your current plan's next step" : ''
-      lines.push( `${ i + 1 }. ${ c.schema }${ to }${ plan }` )
+      const plan = c.fromPlan ? " (your current plan's next step)" : ''
+      lines.push( `${ i + 1 }. ${ c.schema }${ to }${ what }${ plan }` )
     })
     return lines.join( '\n' )
   }

package/src/cognition/agency/engines/motor.schema.executor.ts

@@ -464,6 +464,8 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         payload: {
           schema: intent.schema, intentId: intent.id,
           targetEntityId: intent.targetEntityId, parameters: intent.parameters, tick,
+          // The ability's declared meaning, carried to the host handler.
+          description: this._resolve( intent.schema )?.description,
         },
       })
     }

package/src/cognition/agency/schemas/external.ts

@@ -21,37 +21,54 @@
 // entity schema. See CUSTOM_EFFECTOR_WIRING_TODO.md.
 // ─────────────────────────────────────────────────────────────
 
-import type { MotorSchema } from '#agency/types'
+import type { MotorSchema, EffectorDeclaration } from '#agency/types'
 import { EXPLICIT_EFFECTORS } from '#agency/access.grants'
 import { INNATE_SCHEMA_BY_ID } from '#agency/schemas/innate'
 
 /** Default effort/energy demand for a host action when none is specified. */
 const DEFAULT_EXTERNAL_COST = 0.15
 
+const clamp = ( n: number, lo: number, hi: number ): number => n < lo ? lo : n > hi ? hi : n
+
 /**
  * Build enactable MotorSchemas for a host's declared domain effectors. Comms
  * names and innate-shadowing names are filtered out; the rest become objectless,
  * `external`-tagged primitives that route to the host on enaction.
+ *
+ * A declaration may be a bare name (uniform prior) or an object carrying the
+ * ability's meaning + intrinsic priors (`description`, `cost`, `valence`,
+ * `preconditions`) — these seed the affordance so the ability competes with a
+ * real effort/reward/gating profile instead of a flat default. Reafference
+ * refines them from there.
  */
-export function externalSchemas( effectors?: string[] | null ): MotorSchema[] {
+export function externalSchemas( effectors?: EffectorDeclaration[] | null ): MotorSchema[] {
   const seen = new Set<string>()
   const out:  MotorSchema[] = []
 
-  for( const name of effectors ?? [] ){
+  for( const decl of effectors ?? [] ){
+    const name = typeof decl === 'string' ? decl : decl?.name
     if( typeof name !== 'string' || name.length === 0 ) continue
     if( EXPLICIT_EFFECTORS.has( name ) )  continue   // communication — handled by AccessGrants
     if( INNATE_SCHEMA_BY_ID.has( name ) ) continue   // shadows an innate stance
     if( seen.has( name ) )                continue
     seen.add( name )
 
+    const meta = typeof decl === 'string' ? null : decl
+    const binds = meta?.binds === 'entity' ? 'entity' : meta?.binds === 'object' ? 'object' : 'none'
+    // Declared routing tags merged with the mandatory 'external'/'host' markers
+    // (the executor routes on 'external'; dedup keeps the set clean).
+    const tags = [ ...new Set( [ ...( meta?.tags ?? [] ), 'external', 'host' ] ) ]
+
     out.push({
-      id:          name,
-      kind:        'primitive',
-      source:      'external',
-      cost:        DEFAULT_EXTERNAL_COST,
-      binds:       'none',
-      baseValence: 0,
-      tags:        [ 'external', 'host' ],
+      id:            name,
+      kind:          'primitive',
+      source:        'external',
+      cost:          typeof meta?.cost === 'number' ? clamp( meta.cost, 0, 1 ) : DEFAULT_EXTERNAL_COST,
+      binds,
+      baseValence:   typeof meta?.valence === 'number' ? clamp( meta.valence, -1, 1 ) : 0,
+      ...( meta?.preconditions ? { preconditions: meta.preconditions } : {} ),
+      ...( meta?.description   ? { description:   meta.description   } : {} ),
+      tags,
     })
   }
 

package/src/cognition/agency/schemas/repertoire.ts

@@ -71,6 +71,16 @@ export class SchemaRepertoire {
       this._skills.set( schema.id, freshSkill( schema.id, 0.4, 0 ) )
   }
 
+  /**
+   * Register a host effector's primitive schema at runtime (post-create
+   * `.effector()`). Unlike a composite it is NOT marked learned — it is a
+   * capacity the host granted, which the synthesizer surfaces immediately and
+   * reafference then builds skill on. Idempotent; re-registering updates it.
+   */
+  registerExternal( schema: MotorSchema ): void {
+    this._templates.set( schema.id, schema )
+  }
+
   // ── skills ────────────────────────────────────────────────────
   skills(): ReadonlyMap<string, LearnedSkill> { return this._skills }
   getSkill( id: string ): LearnedSkill | undefined { return this._skills.get( id ) }
@@ -221,6 +231,7 @@ function schemaEntity( s: MotorSchema ): EntityInput {
       preconditions: s.preconditions,
       composedOf:    s.composedOf,
       baseValence:   s.baseValence,
+      description:   s.description,
       tags:          s.tags,
     },
   }
@@ -241,6 +252,7 @@ function readSchema( m: Record<string, unknown> | undefined ): MotorSchema | und
     preconditions: meta['preconditions'] as MotorSchema['preconditions'],
     composedOf:    Array.isArray( meta['composedOf'] ) ? meta['composedOf'] as string[] : undefined,
     baseValence:   typeof meta['baseValence'] === 'number' ? meta['baseValence'] as number : undefined,
+    description:   typeof meta['description'] === 'string' ? meta['description'] as string : undefined,
     tags:          Array.isArray( meta['tags'] ) ? meta['tags'] as string[] : undefined,
   }
 }

package/src/cognition/agency/types.ts

@@ -29,8 +29,12 @@ export interface SchemaPrecondition {
   value:  number
 }
 
-/** What kind of target a schema binds when it becomes an affordance. */
-export type SchemaBinding = 'none' | 'entity' | 'percept'
+/**
+ * What kind of target a schema binds when it becomes an affordance.
+ * 'entity' = a sentient known-entity (a person); 'object' = a non-sentient
+ * known-entity (a thing); 'percept' = a salient percept; 'none' = objectless.
+ */
+export type SchemaBinding = 'none' | 'entity' | 'object' | 'percept'
 
 /**
  * A MotorSchema — a parameterized control program, not a flat effector row.
@@ -52,9 +56,52 @@ export interface MotorSchema {
   composedOf?:   string[]
   /** Intrinsic affective prior (−1..1) before any learning has occurred. */
   baseValence?:  number
+  /** What the schema is *for* — its meaning, carried to the host on enaction. */
+  description?:  string
   tags?:         string[]
 }
 
+/**
+ * How a host declares a domain effector to a Will. A bare string is the
+ * name-only form (`CUSTOM_ABILITY_WIRING.md` Phase 1). The object form seeds the
+ * ability as a *learnable affordance*: `description` is its meaning; `cost`,
+ * `valence`, and `preconditions` are the intrinsic priors the mind starts from
+ * before reafference refines them through use. Args still bind from the
+ * situation — this is not a tool-call parameter form.
+ */
+export type EffectorDeclaration =
+  | string
+  | {
+      name:           string
+      /** What the ability is for — its meaning, carried to perception + the host. */
+      description?:   string
+      /** Intrinsic effort/energy demand 0..1 (default 0.15). */
+      cost?:          number
+      /** Intrinsic affective prior −1..1 the mind expects before learning (default 0). */
+      valence?:       number
+      /** Body-state gates; the affordance is unavailable unless all pass. */
+      preconditions?: SchemaPrecondition[]
+      /**
+       * Whether the ability targets a specific *perceived* target (default
+       * 'none'). 'entity' binds it to each sentient known-entity (a person),
+       * 'object' to each non-sentient one (a thing) — so the Will can
+       * `give`/`greet` someone or `use`/`pick-up` something in particular; the
+       * bound target reaches the host as `ctx.targetEntityId`.
+       */
+      binds?:         'none' | 'entity' | 'object'
+      /**
+       * Routing tags folded into the schema (merged with 'external'/'host').
+       * A tag the drive system recognises (e.g. 'social', 'nourishment') lets a
+       * homeostatic drive lift this ability in the competition when pressing.
+       */
+      tags?:          string[]
+    }
+
+/** The effector name of a declaration, whichever form it takes. */
+export function effectorName( d: EffectorDeclaration ): string {
+  return typeof d === 'string' ? d : d.name
+}
+
 /**
  * An Affordance — a possibility the current state affords *for this body now*,
  * with its parameters already bound from the thing that evoked it. Parameters
@@ -85,6 +132,8 @@ export interface Affordance {
   available:       boolean
   /** Schema tags, carried so selection can route drives/risk without the registry. */
   tags:            string[]
+  /** The ability's declared meaning (external effectors) — what it is for. */
+  description?:    string
   /**
    * Top-down planning bias 0..1 — set when an executing plan's frontier step
    * projected this affordance (source 'plan'). It lifts activation in the

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

@@ -399,10 +399,15 @@ function resolveKnownEntity( target: string, state: ReadonlySimulationState ): s
 }
 
 /**
- * Turn the executive's imagined communicate actions into `ideomotor.intent` entities
- * (the ideomotor leg). The AffordanceSynthesizer surfaces them as competing reach-out
- * affordances next tick. Refreshed each executive cycle — stale intents the executive
- * no longer imagines are deleted, so a momentary "I'd like to reach out" doesn't linger.
+ * Turn the executive's imagined actions into `ideomotor.intent` entities (the
+ * ideomotor leg). Two kinds are pre-activated: communicate actions (as reach-out
+ * toward the resolved entity) and *currently-afforded host abilities* — an action
+ * whose type names an external affordance in the field, optionally carrying the
+ * `args` the executive consciously supplied (a mind formulating "search the docs
+ * for X" IS the situation providing the argument). The AffordanceSynthesizer
+ * surfaces them as competing candidates next tick — executive intention ENTERS
+ * the competition, it never bypasses it. Refreshed each executive cycle — stale
+ * intents the executive no longer imagines are deleted.
  */
 function buildIdeomotorIntents(
   output:    ExecutiveOutputFull,
@@ -413,16 +418,47 @@ function buildIdeomotorIntents(
   const seen = new Set<string>()
   const priority = clamp01( output.confidence ?? 0.8 )
 
+  // The host abilities currently afforded (source 'external' in the live field) —
+  // the executive can only pre-activate what the situation actually offers.
+  const externalBySchema = new Map<string, string>()
+  for( const e of state.entities.values() ){
+    if( e.type !== 'affordance' ) continue
+    const m = e.metadata as Record<string, unknown> | undefined
+    if( m?.['source'] !== 'external' ) continue
+    const schema = typeof m['schema'] === 'string' ? m['schema'] as string : undefined
+    if( schema ) externalBySchema.set( schema.toLowerCase(), schema )
+  }
+
   for( const action of output.actions ){
-    if( !COMMUNICATE_ACTION_TYPES.has( action.type.toLowerCase() ) ) continue
-    if( !action.target ) continue
-    const keid = resolveKnownEntity( action.target, state )
-    if( !keid || seen.has( keid ) ) continue
-    seen.add( keid )
+    const t = action.type.toLowerCase()
+
+    if( COMMUNICATE_ACTION_TYPES.has( t ) ){
+      if( !action.target ) continue
+      const keid = resolveKnownEntity( action.target, state )
+      if( !keid || seen.has( keid ) ) continue
+      seen.add( keid )
+      set.push({
+        id:   `ideomotor-reach-out-${ keid }`,
+        type: 'ideomotor.intent',
+        metadata: { schema: 'reach-out', targetEntityId: keid, priority, origin: 'executive', tick: footprint.tickObserved },
+      })
+      continue
+    }
+
+    // A host ability the executive imagines enacting, with its conscious args.
+    const schema = externalBySchema.get( t )
+    if( !schema || seen.has( `ability:${ schema }` ) ) continue
+    seen.add( `ability:${ schema }` )
+    const keid = action.target ? resolveKnownEntity( action.target, state ) : undefined
     set.push({
-      id:   `ideomotor-reach-out-${ keid }`,
+      id:   `ideomotor-${ schema }${ keid ? `-${ keid }` : '' }`,
       type: 'ideomotor.intent',
-      metadata: { schema: 'reach-out', targetEntityId: keid, priority, origin: 'executive', tick: footprint.tickObserved },
+      metadata: {
+        schema,
+        ...( keid ? { targetEntityId: keid } : {} ),
+        ...( action.args && typeof action.args === 'object' ? { parameters: action.args } : {} ),
+        priority, origin: 'executive', tick: footprint.tickObserved,
+      },
     })
   }
 

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

@@ -322,6 +322,7 @@ export async function buildExecutiveContext(
     plans,
     relevantPlanIds,
     percepts,
+    abilities: extractAbilities( state ),
     workingMemory,
     memories,
     beliefs,
@@ -334,6 +335,33 @@ export async function buildExecutiveContext(
   }
 }
 
+/**
+ * Host-declared abilities afforded to the Will right now — read from the current
+ * `affordance` field (source 'external', available). Gives System 2 knowledge of
+ * what it can do + what each is for; the innate stances are already in the
+ * preamble, so only host effectors surface here. Capped so a wide catalog can't
+ * bloat the prompt.
+ */
+const MAX_SURFACED_ABILITIES = 8
+export function extractAbilities( state: ReadonlySimulationState ): ExecutiveContext['abilities'] {
+  const out: NonNullable<ExecutiveContext['abilities']> = []
+  for( const e of state.entities.values() ){
+    if( e.type !== 'affordance' ) continue
+    const m = e.metadata as Record<string, unknown> | undefined
+    if( m?.['source'] !== 'external' || m?.['available'] === false ) continue
+    const name = typeof m?.['schema'] === 'string' ? m['schema'] as string : undefined
+    if( !name ) continue
+    const description = typeof m['description'] === 'string' ? m['description'] as string : undefined
+    const params = m['parameters'] as Record<string, unknown> | undefined
+    const target = m['targetEntityId']
+      ? ( typeof params?.['targetEntityName'] === 'string' ? params['targetEntityName'] as string : String( m['targetEntityId'] ) )
+      : undefined
+    out.push( { name, ...( description ? { description } : {} ), ...( target ? { target } : {} ) } )
+    if( out.length >= MAX_SURFACED_ABILITIES ) break
+  }
+  return out.length > 0 ? out : undefined
+}
+
 /**
  * What the Will is currently focused on (the `task-switch-focus` entity from task.switcher)
  * plus the effort cost of switching away (the `task_switch.switch_cost` metric = effective

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

@@ -133,9 +133,15 @@ export class FacetSupervisor {
   }
 
   private _reapIdle( tick: number ): void {
-    for( const [ id, facet ] of [ ...this._facets ] )
+    for( const [ id, facet ] of [ ...this._facets ] ){
+      // Never reap a busy facet: queued reports / an in-flight LLM call span
+      // many ticks (a real call is 10–30s), and destroying the facet clears the
+      // listeners its pending decision lands on — a conversation reply would
+      // vanish silently. The TTL measures *quiet* facets only.
+      if( facet.busy ) continue
       if( tick - facet.lastActiveTick > this._idleTtlTicks )
         this._reap( id, 'idle' )
+    }
   }
 
   /** Destroy + deregister a facet and notify its owner. Shared by the reaper + LRU eviction. */
@@ -163,8 +169,16 @@ export class FacetSupervisor {
   }
 
   private _leastRecentlyActive(): string | null {
+    // Prefer a quiet victim: evicting a busy facet drops its in-flight decision
+    // (same silent-loss mode the idle reaper guards against). Only when every
+    // facet is busy does pressure eviction fall back to the absolute LRU — a
+    // new conversation still preempts rather than being refused.
     let id: string | null = null
     let min = Infinity
+    for( const [ fid, facet ] of this._facets )
+      if( !facet.busy && facet.lastActiveTick < min ){ min = facet.lastActiveTick; id = fid }
+    if( id ) return id
+
     for( const [ fid, facet ] of this._facets )
       if( facet.lastActiveTick < min ){ min = facet.lastActiveTick; id = fid }
     return id

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

@@ -149,6 +149,16 @@ export class ExecutiveFacet {
   /** Stamp activity at `tick` (called at spawn and on each report). */
   markActive( tick: number ): void { this._lastActiveTick = tick }
 
+  /** _reason() calls currently in flight — a real LLM call spans many ticks. */
+  private _inflight = 0
+  /**
+   * True while the facet has work the reaper must not discard: queued reports
+   * awaiting the pump, or an in-flight _reason() whose decision hasn't landed.
+   * The idle TTL only measures *quiet* facets — reaping a busy one destroys the
+   * listeners its pending decision needs, silently dropping a conversation reply.
+   */
+  get busy(): boolean { return this._inflight > 0 || this._pendingReports.length > 0 }
+
   /**
    * Per-facet chunk handler — fires for every LLM token during _reason().
    * Set by the creating engine (e.g. AuditionEngine) for entity-scoped streaming.
@@ -236,9 +246,27 @@ export class ExecutiveFacet {
     }
 
     // Legacy (bare facets in unit tests): trigger reasoning immediately.
-    this._reason( report ).catch( err =>
-      logger.error( `[executive.facet] ${this.facetId} reasoning error:`, err )
-    )
+    this._launchReason( report )
+  }
+
+  /**
+   * Launch _reason() with in-flight accounting. `busy` must hold for the whole
+   * span (a real LLM call is 10–30s ≈ many ticks) so the supervisor's idle
+   * reaper never destroys a facet whose decision is still coming — that would
+   * clear its listeners and silently drop the reply. Completion re-stamps
+   * activity so the idle TTL measures quiet time *after* the decision, not
+   * after the report that started it.
+   */
+  private _launchReason( report: FacetReport ): void {
+    this._inflight++
+    this._reason( report )
+      .catch( err =>
+        logger.error( `[executive.facet] ${this.facetId} reasoning error:`, err )
+      )
+      .finally( () => {
+        this._inflight--
+        this.markActive( ( this._currentStateRef?.tick as number ) ?? this._lastActiveTick )
+      })
   }
 
   /**
@@ -257,9 +285,7 @@ export class ExecutiveFacet {
     this._pendingReports = []
 
     for( const report of batch )
-      this._reason( report ).catch( err =>
-        logger.error( `[executive.facet] ${this.facetId} reasoning error:`, err )
-      )
+      this._launchReason( report )
   }
 
   subscribe( listener: FacetEventListener ): () => void {

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

@@ -344,7 +344,7 @@ ${roleDescription}
 ${consciousnessArchitecture}
 
 ## Output Guidelines
-- **actions**: Choose from effectors you know about. If uncertain, describe what you want to achieve in natural language and your body will try to match it.
+- **actions**: Choose from effectors you know about. If uncertain, describe what you want to achieve in natural language and your body will try to match it. When enacting one of your available abilities that needs specifics (a query, a message, a value), supply them in the action's "args" object — e.g. {"type": "search_docs", "args": {"query": "tick loop design"}, ...}. Your body enacts the ability with exactly those args.
 - **plans**: Include for goals without existing plans or where plans need revision. You may keep multiple plans per goal — set **planId** to act on a specific existing plan (validate/execute/revise/cancel); omit it to draft a new one. Your current plans are listed under "## Active Plans".
 - **newBeliefs**: Extract patterns from experiences visible in your current state. Only record a belief if you can point to a specific observation that supports it — do not infer experiences you have no record of. Set 'evidence' honestly: 'single_observation' (first time noticing), 'recurring_pattern' (seen multiple times), 'strong_pattern' (deeply established).
 - **introspection**: Include when significant events occurred or you notice patterns. When you spot a cognitive bias in your own reasoning, name it in 'identifiedBiases' using its common term where one fits (e.g. overgeneralization, confirmation bias, recency bias) — this lets your self-assessment line up with the patterns your faculties detect on their own.
@@ -643,6 +643,15 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       ? `## Percepts (What You Notice)\n${context.percepts.slice( 0, 10 ).map( p => `- [${p.category}] ${p.summary} (salience: ${p.salience.toFixed( 2 )})` ).join( '\n' ) || 'Nothing notable'}`
       : ''
 
+    // Host abilities afforded right now + what each is for. Framed as
+    // self-knowledge (things you *can* do), NOT a tool-call menu: the Will still
+    // expresses intent in natural language and the agency field enacts the fit.
+    const abilitiesBlock = ( context.abilities && context.abilities.length > 0 )
+      ? `## Abilities Available Now\nThings you can do in this situation — name one as an action's "type" (with "args" for any specifics it needs) and your body enacts it:\n${context.abilities.map( a =>
+          `- **${a.name}**${a.target ? ` (toward ${a.target})` : ''}${a.description ? ` — ${a.description}` : ''}`
+        ).join( '\n' )}`
+      : ''
+
     const ruminationsBlock = has( 'ruminations' )
       ? `## Active Ruminations (retrieved memories & thoughts)\n${context.workingMemory.map( w => `- [${w.type}] ${w.summary} (activation: ${w.activation.toFixed( 2 )})` ).join( '\n' ) || 'Nothing actively held in mind'}`
       : ''
@@ -694,6 +703,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       actionDiversity.trim(),
       recentOutcomesBlock,
       perceptsBlock,
+      abilitiesBlock,
       ruminationsBlock,
       recentIntrospection.trim(),
       memoriesBlock,