@mindot/will 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindot/will",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "author": "Fabrice <fabrice8@github.com>",
   "repository": {
     "type": "git",

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

@@ -38,6 +38,7 @@ import {
 import { readEffectiveParams, readPersonaPrior } from '#cognition/persona.prior'
 import { RUPTURE_REVOKE_GATE, revocationEntity } from '#agency/revocation'
 import { liveConsequences, matchConsequenceText } from '#agency/consequence'
+import { asFinality } from '#stem/policy/arbiter'
 
 /**
  * Activation margin (winner − runner-up) below which the choice is "contested" —
@@ -294,19 +295,26 @@ export class ActionSelector implements CognitiveEngine {
       }
     })
 
-    // ── Commitment revocation (EXAFFERENCE P4) ───────────────────
-    // A hard rupture doesn't just soften the switch cost — it lets go of a
-    // commitment still being weighed. We can't delete the `deliberating` intent
-    // here (Deliberation runs after us and would resurrect it set-after-delete),
-    // so we drop a tombstone the Deliberation engine + Executor honor next tick.
-    // No successor is committed — the field re-forms and the next tick selects.
-    if( deliberating && rupture >= RUPTURE_REVOKE_GATE ){
+    // ── Commitment revocation (EXAFFERENCE P4 · POLICY_REAFFERENCE P3) ──
+    // A commitment still being weighed is let go for either of two DISTINCT
+    // reasons: a hard exafferent rupture (the world surprised us), or a class
+    // policy refusal of the very schema we're deliberating (the boundary just
+    // declared it forbidden — deliberating our way into it is wasted). The two
+    // never mix: the refusal is an outcome, not a percept, so it contributes
+    // ZERO to the exafferent scalar. Either way we can't delete the
+    // `deliberating` intent here (Deliberation runs after us and would resurrect
+    // it set-after-delete), so we drop a tombstone the Deliberation engine +
+    // Executor honor next tick. No successor is committed — the field re-forms.
+    const policyRevoke = !!deliberating && refusedClassSchemas( state ).has( deliberating.schema )
+    if( deliberating && ( rupture >= RUPTURE_REVOKE_GATE || policyRevoke ) ){
+      const reason     = policyRevoke ? 'policy-refusal' : 'exafferent-rupture'
+      const revRupture = policyRevoke ? Math.max( rupture, RUPTURE_REVOKE_GATE ) : rupture
       if( this._bus ){
         try {
           this._bus.publish({
             type: 'agency.commitment.revoked', version: 1, sourceEngine: this.name,
             salience: 0.85,
-            payload: { from: deliberating.schema, reason: 'exafferent-rupture', rupture, tick },
+            payload: { from: deliberating.schema, reason, rupture: revRupture, tick },
           })
         }
         catch( err ){ logger.warn(`[selector] revoked publish failed: ${ err instanceof Error ? err.message : String( err ) }`) }
@@ -314,11 +322,12 @@ export class ActionSelector implements CognitiveEngine {
       this._lastRevoked = { schema: deliberating.schema, tick }   // Channel-B: flavor the next deliberation
       return {
         commands: {
-          set: [ revocationEntity( deliberating.id, deliberating.schema, rupture, tick ) ],
+          set: [ revocationEntity( deliberating.id, deliberating.schema, revRupture, tick ) ],
           metrics: [
             [ 'agency.field.eligible', eligible.length ],
             [ 'agency.selection.busy', 1 ],
             [ 'agency.commitment.revoked', 1 ],
+            ...( policyRevoke ? [ [ 'agency.policy.revoked', 1 ] as [ string, number ] ] : [] ),
             ...stabMetrics,
           ],
         },
@@ -632,6 +641,30 @@ function computeRupture(
   return clamp01( ( maxSalience - RUPTURE_SALIENCE_GATE ) / ( 1 - RUPTURE_SALIENCE_GATE ) )
 }
 
+/**
+ * POLICY_REAFFERENCE P3 — schemas hit by a CLASS-final policy refusal visible in
+ * frozen state this tick (a refused `agency.outcome` lives exactly one tick).
+ *
+ * A refusal is an `agency.outcome`, never a `percept`, so it can NEVER feed
+ * computeRupture: the mind cannot rupture itself with its own boundary. This is
+ * a SEPARATE, explicit trigger — "the boundary just declared this forbidden, let
+ * go of any commitment I'm still weighing toward it" — distinct from a
+ * world-surprise exafferent rupture, and it carries its own revocation reason.
+ * Only `class` finality qualifies: an `instance` refusal means "not with those
+ * parameters", not "never", so a still-deliberating attempt may yet succeed.
+ */
+function refusedClassSchemas( state: ReadonlySimulationState ): Set<string> {
+  const out = new Set<string>()
+  for( const e of state.entities.values() ){
+    if( e.type !== 'agency.outcome') continue
+    const m = e.metadata
+    if( m?.['refused'] !== true || asFinality( m?.['finality'] ) !== 'class') continue
+    const schema = str( m?.['schema'] )
+    if( schema ) out.add( schema )
+  }
+  return out
+}
+
 /**
  * Competition weights = DEFAULT_WEIGHTS with the two trait-owned ones (risk, novelty)
  * overridden by their developed values (base ⊕ prior). Negative weights are clamped to

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

@@ -103,6 +103,9 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // means the executor, which ticks later in the SAME tick, sees a whole
     // repertoire and can expand a restored mid-flight macro. Idempotent.
     this._repertoire?.restoreComposites( state.entities )
+    // Availability entries (P2) rehydrate the same way, so a restored Will keeps
+    // its learned suppressions instead of re-probing forbidden abilities.
+    this._repertoire?.restoreAvailability( state.entities )
 
     const schemas   = this._repertoire?.schemas() ?? this._schemas
     const skills    = this._skills?.() ?? this._repertoire?.skills() ?? null
@@ -306,6 +309,10 @@ export class AffordanceSynthesizer implements CognitiveEngine {
   ): Affordance {
     const skill = skills?.get( schema.id )
 
+    // Policy availability (P2): omitted when fully available (1), so a never-refused
+    // Will's affordance field is byte-identical. Present only once a refusal dented it.
+    const availability = this._repertoire?.availabilityOf( schema.id ) ?? 1
+
     // Learned value if known, else the schema's intrinsic prior mapped to 0..1.
     const expectedReward = skill?.valueEstimate ?? clamp01( ( ( schema.baseValence ?? 0 ) + 1 ) / 2 )
     const expectedValence = schema.baseValence ?? valence
@@ -333,6 +340,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       available:       this._available( schema.preconditions, ( k ) => metric( state, k, 0 ) ),
       tags:            schema.tags ?? [],
       ...( schema.description ? { description: schema.description } : {} ),
+      ...( availability < 1 ? { availability } : {} ),
       planBias:        ctx.planBias,
       planId:          ctx.planId,
       stepId:          ctx.stepId,
@@ -357,6 +365,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         available:       a.available,
         tags:            a.tags,
         description:     a.description,
+        ...( a.availability !== undefined ? { availability: a.availability } : {} ),
         planBias:        a.planBias,
         planId:          a.planId,
         stepId:          a.stepId,

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

@@ -179,6 +179,10 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     // outcome (which also teaches reafference the action is unreliable here).
     for( const [ id, e ] of state.entities ){
       if( e.type !== 'agency.intent' || str( e.metadata?.['status'] ) !== 'awaiting') continue
+      // POLICY_REAFFERENCE P4 — an escalated intent is HELD: the stem owns its
+      // lifecycle (extended TTL → approve/deny/expire), so the executor must not
+      // time it out at AWAIT_TIMEOUT and reconcile it as a phantom failure.
+      if( e.metadata?.['escalated'] === true ) continue
       const dispatchedAt = num( e.metadata?.['dispatchedAt'], tick )
       if( tick - dispatchedAt < AWAIT_TIMEOUT ) continue
 

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

@@ -28,7 +28,8 @@ import type { CognitiveBus, CognitiveEvent } from '#cognition/bus'
 import type { CognitiveEngine, EngineResult } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { SchemaRepertoire } from '#agency/schemas/repertoire'
-import { schemaEntityId } from '#agency/schemas/repertoire'
+import { schemaEntityId, availabilityEntityId } from '#agency/schemas/repertoire'
+import { asFinality } from '#stem/policy/arbiter'
 import { AWAIT_TIMEOUT } from '#agency/engines/motor.schema.executor'
 
 const PROC_THRESHOLD = 0.60   // mirror of repertoire's threshold for the habitual-count metric
@@ -190,10 +191,37 @@ export class ReafferenceEngine implements CognitiveEngine {
     // ── 1. Fold each outcome into its skill ──────────────────────
     let updates    = 0
     let discovered = 0
+    let refused    = 0
     for( const { id, meta: m, fromState } of outcomes ){
       const schema = str( m['schema'] )
       if( !schema ){ if( fromState ) del.push( id ); continue }
 
+      // POLICY_REAFFERENCE P2 — a refusal is NOT a failure. Route it to the
+      // availability layer and stop: it must never touch LearnedSkill (value,
+      // habit, param priors), or the Will learns it is unskilled at something it
+      // is merely forbidden to do. The awaiting intent is still freed, and a
+      // refused plan step is signalled unsuccessful so the plan doesn't hang.
+      if( m['refused'] === true ){
+        const finality = asFinality( m['finality'] )
+
+        // P5 — 'context' means the refusal was NOT ABOUT THE ACTION (tainted
+        // context, an unavailable dependency, the arbiter itself down). Denting
+        // availability here would teach a lesson the policy never taught:
+        // "reach for this less", when nothing about the ability was the problem.
+        // So the intent is freed and the plan step signalled — the mind must not
+        // hang — and NOTHING else is written. Not competence, not availability.
+        if( finality !== 'context')
+          this._repertoire.recordRefusal( schema, finality, tick )
+
+        if( fromState ) del.push( id )
+        const refusedIntent = str( m['intentId'] )
+        if( refusedIntent ) del.push( refusedIntent )
+        const refusedPlan = str( m['planId'] )
+        if( refusedPlan ) this._emitPlanOutcome( refusedPlan, str( m['stepId'] ), schema, false, 0, 0, tick )
+        refused++
+        continue
+      }
+
       const { skill, proceduralized } = this._repertoire.recordOutcome({
         schema,
         success:         m['success'] === true,
@@ -235,19 +263,23 @@ export class ReafferenceEngine implements CognitiveEngine {
       }
     }
 
-    // ── 2. Forgetting curve over the competence layer ────────────
+    // ── 2. Forgetting curve over the competence layer + availability recovery ──
     const dropped = this._repertoire.decay( tick )
-    for( const id of dropped ){
+    for( const id of dropped.skills ){
       del.push(`agency-skill-${ id }`)
       del.push( schemaEntityId( id ) )   // composite mirror (harmless no-op for primitives)
     }
+    for( const id of dropped.availability )
+      del.push( availabilityEntityId( id ) )   // fully-recovered ⇒ remove the mirror
 
-    // ── 3. Mirror learned composite templates ────────────────────
+    // ── 3. Mirror learned composite templates + availability ─────
     // Skills become `agency.skill` (above); the invented composite *definitions*
     // must travel too, or a snapshot/restore brings back a skill whose schema is
     // gone and the executor can't expand it. Idempotent re-write each tick, like
     // GoalManager._persistGoals. Empty until a composite is actually learned.
-    for( const e of this._repertoire.compositeEntities() ) set.push( e )
+    for( const e of this._repertoire.compositeEntities() )   set.push( e )
+    // Availability entries (P2) mirror the same way — empty until a refusal lands.
+    for( const e of this._repertoire.availabilityEntities() ) set.push( e )
 
     // ── 4. Telemetry ─────────────────────────────────────────────
     const skills    = this._repertoire.skills()
@@ -259,6 +291,9 @@ export class ReafferenceEngine implements CognitiveEngine {
       [ 'agency.habitual.count',   habitual ],
       [ 'agency.sensory.confirmed', sensory ],
     )
+    // Only emit the refusal metric when it fired — a never-refused Will writes
+    // nothing here, preserving the byte-identical quiet path (cf. EXAFFERENCE P3).
+    if( refused > 0 ) metrics.push([ 'agency.refused.count', refused ])
 
     return { commands: { set, delete: del, metrics } }
   }

package/src/cognition/agency/reconcile.learning.ts

@@ -16,6 +16,7 @@
 // ─────────────────────────────────────────────────────────────
 
 import type { EntityInput, Tick } from '#core/types'
+import type { DenialFinality, PolicyCounterfactual } from '#stem/policy/arbiter'
 
 export interface HostAckResult {
   success:        boolean
@@ -24,6 +25,24 @@ export interface HostAckResult {
   /** −1..1 felt valence of the outcome. */
   valence?:       number
   description?:   string
+  /**
+   * POLICY_REAFFERENCE P2 — this ack is a policy REFUSAL, not a world failure.
+   * The ReafferenceEngine routes it to the availability layer (NOT competence):
+   * a refusal must never teach the Will it is unskilled at something it is merely
+   * forbidden to do. `finality` decides how hard availability is cut.
+   */
+  refused?:       boolean
+  finality?:      DenialFinality
+  /**
+   * ENVELOPE_NARROWING P0 — what WOULD have been permitted, e.g.
+   * `{ field: 'amount', requested: 500, allowed: 100 }`.
+   *
+   * Carried onto the outcome so the tape and the thing the mind actually learns
+   * from agree about what happened. Until ENVELOPE_NARROWING P1 lands nothing
+   * READS it — that fold is blocked upstream on whether a scalar `allowed` is a
+   * ceiling or a floor — but dropping it here is what made the two disagree.
+   */
+  counterfactual?: PolicyCounterfactual
 }
 
 /**
@@ -71,6 +90,10 @@ export function reconcileInvocation(
       mode:             'external',
       tick,
       reconciled:       true,
+      ...( result.refused ? { refused: true, finality: result.finality ?? 'parameter' } : {} ),
+      // Only when the arbiter actually reported a bound — a refusal without one
+      // writes no key at all, so the quiet path is unchanged.
+      ...( result.refused && result.counterfactual ? { counterfactual: result.counterfactual } : {} ),
       ...( provenance.planId ? { planId: provenance.planId } : {} ),
       ...( provenance.stepId ? { stepId: provenance.stepId } : {} ),
     },

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

@@ -26,6 +26,7 @@
 
 import type { MotorSchema, LearnedSkill } from '#agency/types'
 import type { EntityInput, ReadonlySimulationState } from '#core/types'
+import type { DenialFinality } from '#stem/policy/arbiter'
 import { INNATE_SCHEMAS } from '#agency/schemas/innate'
 
 const VALUE_ALPHA       = 0.2   // value EMA rate
@@ -39,6 +40,23 @@ const IDLE_TICKS        = 200   // ticks of disuse before forgetting starts
 const DECAY_RATE        = 0.02  // habit lost per decay application
 const DROP_HABIT        = 0.05  // below this (and learned) the skill is forgotten
 
+// ── availability layer (POLICY_REAFFERENCE P2) ────────────────
+// Availability is NOT competence. It answers "may I use this schema", learned
+// from policy refusals, and is kept strictly apart from LearnedSkill so a
+// refusal never teaches the Will it is *unskilled* at something it is merely
+// *forbidden* to do. A `class` refusal ("never, under this policy") drives
+// availability down hard; an `instance` refusal ("not with those parameters")
+// dents it lightly — the Will should keep reaching for the ability, just not
+// that way. Recovery is slow but real, so a policy change is re-discoverable:
+// availability never floors at zero, and it climbs back toward 1 with disuse of
+// the refusal. P2 keys availability by SCHEMA; per-(schema, params) envelope
+// narrowing is a follow-up that belongs at selection time, not fielding time.
+const AVAIL_DROP_CLASS     = 0.50  // multiplicative cut on a class-final refusal
+const AVAIL_DROP_PARAMETER = 0.12  // lighter cut when only the arguments were refused
+const AVAIL_FLOOR         = 0.05  // never zero — re-probe must always be possible
+const AVAIL_RECOVERY      = 0.02  // per-decay climb back toward 1
+const AVAIL_RECOVERED     = 0.999 // at/above this the entry is dropped (quiet path)
+
 export interface OutcomeObservation {
   schema:         string
   success:        boolean
@@ -54,6 +72,9 @@ export class SchemaRepertoire {
   private _skills    = new Map<string, LearnedSkill>()
   /** Tracks which templates were learned at runtime (vs innate) so decay can forget them. */
   private _learned   = new Set<string>()
+  /** Availability layer (P2): schema → { value 0..1, lastRefusedTick }. Empty until
+   *  a refusal lands — a never-refused Will writes nothing here (byte-identical). */
+  private _availability = new Map<string, { value: number; lastRefusedTick: number }>()
 
   constructor( seed: MotorSchema[] = INNATE_SCHEMAS ){
     for( const s of seed ) this._templates.set( s.id, s )
@@ -85,6 +106,38 @@ export class SchemaRepertoire {
   skills(): ReadonlyMap<string, LearnedSkill> { return this._skills }
   getSkill( id: string ): LearnedSkill | undefined { return this._skills.get( id ) }
 
+  // ── availability (P2) ─────────────────────────────────────────
+  availability(): ReadonlyMap<string, { value: number; lastRefusedTick: number }> { return this._availability }
+
+  /**
+   * How available a schema is right now, 0..1. Absent from the ledger ⇒ 1
+   * (fully available — the common case). This is the ONLY value the
+   * AffordanceSynthesizer reads; it never touches competence.
+   */
+  availabilityOf( schema: string ): number {
+    return this._availability.get( schema )?.value ?? 1
+  }
+
+  /**
+   * Fold a policy refusal into the availability layer (NOT competence). A
+   * `class` refusal cuts availability hard; a `parameter` refusal dents it
+   * lightly. Multiplicative so repeated refusals compound toward — but never
+   * reach — zero, keeping re-probe alive.
+   *
+   * `context` is EXCLUDED FROM THE SIGNATURE, not handled inside: a refusal
+   * that was not about the action must never reach the availability layer at
+   * all, and making that a type error rather than a convention means a future
+   * caller cannot quietly re-introduce the dent. The routing decision lives in
+   * the ReafferenceEngine's refused branch (P5).
+   */
+  recordRefusal( schema: string, finality: Exclude<DenialFinality, 'context'>, tick: number ): number {
+    const prev = this._availability.get( schema )?.value ?? 1
+    const drop = finality === 'class' ? AVAIL_DROP_CLASS : AVAIL_DROP_PARAMETER
+    const value = Math.max( AVAIL_FLOOR, prev * ( 1 - drop ) )
+    this._availability.set( schema, { value, lastRefusedTick: tick } )
+    return value
+  }
+
   /**
    * Fold one outcome into the schema's learned skill. Returns the updated skill
    * and whether it just crossed the proceduralization threshold this update.
@@ -118,12 +171,14 @@ export class SchemaRepertoire {
   }
 
   /**
-   * Forgetting curve over the competence layer. Skills unused for IDLE_TICKS
-   * lose habit; learned composites that fall below DROP_HABIT are dropped
-   * entirely (template + skill). Returns the schema ids that were forgotten.
+   * Forgetting curve over the competence layer, plus availability recovery.
+   * Skills unused for IDLE_TICKS lose habit; learned composites below DROP_HABIT
+   * are dropped entirely (template + skill). Availability entries climb back
+   * toward 1 and are dropped once fully recovered. Returns the ids that were
+   * removed from each layer so their mirrored state entities can be deleted.
    */
-  decay( tick: number ): string[] {
-    const dropped: string[] = []
+  decay( tick: number ): { skills: string[]; availability: string[] } {
+    const skills: string[] = []
     for( const [ id, skill ] of this._skills ){
       if( tick - skill.lastEnactedTick <= IDLE_TICKS ) continue
 
@@ -132,12 +187,23 @@ export class SchemaRepertoire {
         this._skills.delete( id )
         this._templates.delete( id )
         this._learned.delete( id )
-        dropped.push( id )
+        skills.push( id )
         continue
       }
       this._skills.set( id, { ...skill, habitStrength } )
     }
-    return dropped
+
+    // Availability recovery (P2): each entry climbs slowly back toward 1, so a
+    // policy change is re-discoverable. A fully-recovered entry is dropped, so a
+    // Will that was refused long ago returns to the byte-identical quiet path.
+    const availability: string[] = []
+    for( const [ id, avail ] of this._availability ){
+      const value = avail.value + AVAIL_RECOVERY * ( 1 - avail.value )
+      if( value >= AVAIL_RECOVERED ){ this._availability.delete( id ); availability.push( id ) }
+      else this._availability.set( id, { ...avail, value } )
+    }
+
+    return { skills, availability }
   }
 
   // ── PMA portability (Phase 6 reads these) ─────────────────────
@@ -188,6 +254,30 @@ export class SchemaRepertoire {
       this._learned.add( s.id )
     }
   }
+
+  /** Availability ledger encoded as `agency.availability` state entities (P2).
+   *  Empty until a refusal lands, so the quiet path writes nothing. */
+  availabilityEntities(): EntityInput[] {
+    const out: EntityInput[] = []
+    for( const [ schema, a ] of this._availability )
+      out.push( availabilityEntity( schema, a.value, a.lastRefusedTick ) )
+    return out
+  }
+
+  /** Rehydrate the availability ledger from state after a restore. Idempotent;
+   *  keeps whichever value is more restrictive so a concurrent refusal isn't lost. */
+  restoreAvailability( entities: ReadonlySimulationState['entities'] ): void {
+    for( const e of entities.values() ){
+      if( e.type !== AVAILABILITY_ENTITY_TYPE ) continue
+      const m = ( e.metadata ?? {} ) as Record<string, unknown>
+      const schema = typeof m['schema'] === 'string' ? m['schema'] : ''
+      if( !schema ) continue
+      const value = typeof m['value'] === 'number' ? m['value'] : 1
+      const tick  = typeof m['lastRefusedTick'] === 'number' ? m['lastRefusedTick'] : 0
+      const prev  = this._availability.get( schema )
+      if( !prev || value < prev.value ) this._availability.set( schema, { value, lastRefusedTick: tick } )
+    }
+  }
 }
 
 // ─── helpers ─────────────────────────────────────────────────────────────────
@@ -209,6 +299,23 @@ function clamp01( n: number ): number {
   return n < 0 ? 0 : n > 1 ? 1 : n
 }
 
+// ─── availability ⇄ state-entity codec (P2) ──────────────────────────────────
+
+/** State-entity type for a mirrored availability entry. */
+export const AVAILABILITY_ENTITY_TYPE = 'agency.availability'
+
+/** Stable entity id for a schema's availability mirror (idempotent re-writes). */
+export function availabilityEntityId( schema: string ): string { return `agency-availability-${ schema }` }
+
+/** Encode one availability entry as a state entity. */
+function availabilityEntity( schema: string, value: number, lastRefusedTick: number ): EntityInput {
+  return {
+    id:   availabilityEntityId( schema ),
+    type: AVAILABILITY_ENTITY_TYPE,
+    metadata: { schema, value, lastRefusedTick },
+  }
+}
+
 // ─── composite ⇄ state-entity codec (snapshot/replay) ────────────────────────
 
 /** State-entity type for a mirrored composite template. */

package/src/cognition/agency/selection.scoring.ts

@@ -147,7 +147,7 @@ export function scoreAffordance(
   bias: BiasContext,
   w:    ScoreWeights = DEFAULT_WEIGHTS,
 ): number {
-  return (
+  const raw = (
       w.goal    * goalRelevance( a, bias )
     + w.reward  * a.expectedReward
     + w.novelty * novelty( a )
@@ -158,6 +158,12 @@ export function scoreAffordance(
     - w.inhib   * bias.inhibition
     - w.risk    * risk( a, bias )
   )
+  // POLICY_REAFFERENCE P2 — policy availability damps a POSITIVE activation only,
+  // never flipping its sign: a refused ability competes weakly (so it is rarely
+  // chosen) yet is never removed from the field, keeping re-probe alive as
+  // availability recovers. Absent ⇒ 1 ⇒ no change (byte-identical quiet path).
+  const availability = a.availability ?? 1
+  return raw > 0 ? raw * availability : raw
 }
 
 /**

package/src/cognition/agency/types.ts

@@ -140,6 +140,15 @@ export interface Affordance {
    * competition WITHOUT bypassing it (the plan biases; the field still decides).
    */
   planBias?:       number
+  /**
+   * Policy availability 0..1 (POLICY_REAFFERENCE P2) — learned from refusals,
+   * distinct from `available` (precondition satisfaction) and from competence.
+   * Present only when < 1 (a refusal has dented it); absent ⇒ fully available,
+   * so a never-refused Will's field is byte-identical. Damps positive activation
+   * in the competition without flipping its sign, so a suppressed ability still
+   * gets an occasional re-probe and can climb back as availability recovers.
+   */
+  availability?:   number
   /** Provenance: the plan whose frontier step projected this affordance. */
   planId?:         string
   /** Provenance: the frontier step id — flows through to action.outcome so the plan advances. */

package/src/cognition/config.mirror.entities.ts

@@ -34,7 +34,7 @@ export function buildEngineConfigEntities( config: WillConfig, executiveInterval
       engine: 'system',
       params: {
         anatomy:        config.anatomy ?? 'mind',
-        model:          config.model ?? '',
+        model:          config.llm?.model ?? '',
         tickIntervalMs: config.tickIntervalMs ?? 1000
       }
     },