@mindot/will 0.1.1 → 0.3.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.3.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/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/cli.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// ─────────────────────────────────────────────────────────────
+// src/cli.ts — the `will` command: host a persistent mind
+// ─────────────────────────────────────────────────────────────
+//
+//   will mcp     host over MCP stdio (Claude Desktop / Claude Code / IDEs)
+//   will serve   host over HTTP (any language; the sidecar) — WILL_PORT/WILL_HOST
+//
+// Both hosts raise the same mind the same way (see host/boot.ts): env-configured,
+// woken from its PMA artifact when one exists, hibernated back on the way out —
+// the mind PERSISTS across sessions. Shared env: WILL_NAME, WILL_IDENTITY,
+// WILL_TIER, WILL_LLM, WILL_TICK_MS, WILL_SEED, WILL_PMA_PATH, WILL_MCP_SERVERS.
+//
+// MCP client config:
+//   { "command": "npx", "args": ["-y", "@mindot/will", "mcp"],
+//     "env": { "WILL_NAME": "Aria", "WILL_IDENTITY": "I am Aria." } }
+//
+// Sidecar:
+//   WILL_NAME=Aria will serve            # http://127.0.0.1:7777
+//   curl -X POST localhost:7777/perceive -d '{"text":"Hello"}'
+// ─────────────────────────────────────────────────────────────
+
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { routeLogsToStderr, bootWillFromEnv } from '#root/host/boot'
+import { buildWillMcpServer } from '#root/mcp/server'
+import { buildWillHttpServer } from '#root/serve/server'
+
+// stdout is the MCP protocol channel under `will mcp` — route logs FIRST.
+routeLogsToStderr()
+
+const USAGE = `usage: will <mcp | serve>
+
+  mcp     host a persistent mind over MCP stdio (Claude Desktop / Claude Code)
+  serve   host a persistent mind over HTTP (any language; WILL_PORT, default 7777)
+
+Shared env: WILL_NAME, WILL_IDENTITY, WILL_TIER, WILL_LLM, WILL_TICK_MS,
+WILL_SEED, WILL_PMA_PATH, WILL_MCP_SERVERS. The mind persists across runs via
+its PMA artifact.`
+
+async function main(): Promise<void> {
+  const sub = process.argv[2]
+
+  if( sub !== 'mcp' && sub !== 'serve' ){
+    console.error( sub ? `unknown subcommand: ${ sub }\n\n${ USAGE }` : USAGE )
+    process.exit( sub ? 2 : 0 )
+  }
+
+  const { will, name, pmaPath, tickMs, engineTier, onCleanup, shutdown } = await bootWillFromEnv()
+
+  if( sub === 'mcp' ){
+    // The MCP client owns our stdin — its disconnect is the shutdown signal.
+    process.stdin.on( 'end', () => void shutdown( 'client disconnected' ) )
+    const server = buildWillMcpServer( will, { pmaPath } )
+    await server.connect( new StdioServerTransport() )
+    console.error( `[will] ${ name } is listening on MCP stdio (tick ${ tickMs }ms, tier ${ engineTier })` )
+    return
+  }
+
+  // serve — the HTTP sidecar.
+  const port = parseInt( process.env.WILL_PORT ?? '7777' )
+  const host = process.env.WILL_HOST ?? '127.0.0.1'
+  const server = buildWillHttpServer( will, { pmaPath } )
+  onCleanup( () => new Promise<void>( r => server.close( () => r() ) ) )
+  await new Promise<void>( ( resolve, reject ) => {
+    server.once( 'error', reject )
+    server.listen( port, host, () => resolve() )
+  } )
+  console.error( `[will] ${ name } is listening on http://${ host }:${ port } (tick ${ tickMs }ms, tier ${ engineTier })` )
+  console.error( `[will] try: curl -X POST http://${ host }:${ port }/perceive -H 'content-type: application/json' -d '{"text":"Hello"}'` )
+}
+
+main().catch( e => {
+  console.error( `[will] fatal: ${ e instanceof Error ? e.stack ?? e.message : String( e ) }` )
+  process.exit( 1 )
+} )

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