@mindot/will 0.5.0 → 0.7.0

package/dist/cli.js

@@ -3625,11 +3625,19 @@ var PROC_THRESHOLD = 0.6;
 var IDLE_TICKS = 200;
 var DECAY_RATE = 0.02;
 var DROP_HABIT = 0.05;
+var AVAIL_DROP_CLASS = 0.5;
+var AVAIL_DROP_INSTANCE = 0.12;
+var AVAIL_FLOOR = 0.05;
+var AVAIL_RECOVERY = 0.02;
+var AVAIL_RECOVERED = 0.999;
 var SchemaRepertoire = class {
   _templates = /* @__PURE__ */ new Map();
   _skills = /* @__PURE__ */ new Map();
   /** Tracks which templates were learned at runtime (vs innate) so decay can forget them. */
   _learned = /* @__PURE__ */ new Set();
+  /** Availability layer (P2): schema → { value 0..1, lastRefusedTick }. Empty until
+   *  a refusal lands — a never-refused Will writes nothing here (byte-identical). */
+  _availability = /* @__PURE__ */ new Map();
   constructor(seed = INNATE_SCHEMAS) {
     for (const s of seed) this._templates.set(s.id, s);
   }
@@ -3663,6 +3671,31 @@ var SchemaRepertoire = class {
   getSkill(id) {
     return this._skills.get(id);
   }
+  // ── availability (P2) ─────────────────────────────────────────
+  availability() {
+    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) {
+    return this._availability.get(schema)?.value ?? 1;
+  }
+  /**
+   * Fold a policy refusal into the availability layer (NOT competence). A
+   * `class` refusal cuts availability hard; an `instance` refusal dents it
+   * lightly. Multiplicative so repeated refusals compound toward — but never
+   * reach — zero, keeping re-probe alive.
+   */
+  recordRefusal(schema, finality, tick) {
+    const prev = this._availability.get(schema)?.value ?? 1;
+    const drop = finality === "class" ? AVAIL_DROP_CLASS : AVAIL_DROP_INSTANCE;
+    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.
@@ -3689,12 +3722,14 @@ var SchemaRepertoire = class {
     return { skill, proceduralized: !wasProceduralized && habitStrength >= PROC_THRESHOLD };
   }
   /**
-   * 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) {
-    const dropped = [];
+    const skills = [];
     for (const [id, skill] of this._skills) {
       if (tick - skill.lastEnactedTick <= IDLE_TICKS) continue;
       const habitStrength = clamp01(skill.habitStrength - DECAY_RATE);
@@ -3702,12 +3737,20 @@ var SchemaRepertoire = class {
         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;
+    const availability = [];
+    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) ─────────────────────
   /** Learned composite templates + all skills above a confidence floor. */
@@ -3756,6 +3799,28 @@ var SchemaRepertoire = class {
       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() {
+    const out = [];
+    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) {
+    for (const e of entities.values()) {
+      if (e.type !== AVAILABILITY_ENTITY_TYPE) continue;
+      const m = e.metadata ?? {};
+      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 });
+    }
+  }
 };
 function freshSkill(schema, value, tick) {
   return {
@@ -3772,6 +3837,17 @@ function freshSkill(schema, value, tick) {
 function clamp01(n) {
   return n < 0 ? 0 : n > 1 ? 1 : n;
 }
+var AVAILABILITY_ENTITY_TYPE = "agency.availability";
+function availabilityEntityId(schema) {
+  return `agency-availability-${schema}`;
+}
+function availabilityEntity(schema, value, lastRefusedTick) {
+  return {
+    id: availabilityEntityId(schema),
+    type: AVAILABILITY_ENTITY_TYPE,
+    metadata: { schema, value, lastRefusedTick }
+  };
+}
 var SCHEMA_ENTITY_TYPE = "agency.schema";
 function schemaEntityId(schemaId) {
   return `agency-schema-${schemaId}`;
@@ -4655,6 +4731,9 @@ var SleepPressureRegulator = class {
   }
 };
 
+// src/cognition/acp.ts
+var ACP_SELF_PRECISION = 0.35;
+
 // src/cognition/persona.prior.ts
 var PERSONA_PRIOR_ID = "persona-prior";
 var PERSONA_PRIOR_TYPE = "persona.prior";
@@ -4763,6 +4842,8 @@ function consolidatePrior(current, adjustments, tick, opts = {}) {
 }
 
 // src/cognition/faculties/attention.allocator.ts
+var ACP_USAGE_UPLIFT = 0.15;
+var ACP_CONFIDENCE = 0.4;
 var EFFORT_BASELINE2 = 0.7;
 var EFFORT_MIN = 0.4;
 var EFFORT_MAX = 1;
@@ -4784,6 +4865,8 @@ var AttentionAllocator = class {
   _effort = EFFORT_BASELINE2;
   /** A one-shot focus/rest request from the executive, applied next react(). */
   _effortRequest = null;
+  /** ACP-P2: a self-caused precision attenuation is armed; react() restores after one observe. */
+  _acpOneShot = false;
   _bus = null;
   _model = new GenerativeModel();
   constructor(config = {}) {
@@ -4804,8 +4887,12 @@ var AttentionAllocator = class {
       "executive.prediction.formed",
       "attention.regulate",
       // voluntary focus/rest from the executive (Option C)
-      "senses.*"
+      "senses.*",
       // all sense percepts — salience feeds attention allocation
+      // ACP-P2: our own enactions — anticipate the attention swing they cause
+      "agency.enacted",
+      "agency.communicate",
+      "agency.invocation"
     ];
   }
   publishes() {
@@ -4832,6 +4919,18 @@ var AttentionAllocator = class {
           this._model.setPrecision("attention.usage", 1 + p.confidence * 0.5);
         break;
       }
+      case "agency.enacted":
+      case "agency.communicate":
+      case "agency.invocation": {
+        const usage = this._model.predict("attention.usage");
+        const free = this._model.predict("attention.free_fraction");
+        this._model.anticipate("attention.usage", Math.min(1, usage + ACP_USAGE_UPLIFT), ACP_CONFIDENCE);
+        this._model.anticipate("attention.free_fraction", Math.max(0, free - ACP_USAGE_UPLIFT), ACP_CONFIDENCE);
+        this._model.setPrecision("attention.usage", ACP_SELF_PRECISION);
+        this._model.setPrecision("attention.free_fraction", ACP_SELF_PRECISION);
+        this._acpOneShot = true;
+        break;
+      }
       default:
         if (e.type.startsWith("senses.")) {
           const percept = e.payload;
@@ -4915,6 +5014,11 @@ var AttentionAllocator = class {
     if (_bus) {
       const usageErr = this._model.observe("attention.usage", attentionUsage);
       const freeErr = this._model.observe("attention.free_fraction", freeFraction);
+      if (this._acpOneShot) {
+        this._model.setPrecision("attention.usage", 1);
+        this._model.setPrecision("attention.free_fraction", 1);
+        this._acpOneShot = false;
+      }
       if (!usageErr.gated || !freeErr.gated)
         _bus.publish({ type: "attention.state.changed", version: 1, sourceEngine: this.name, salience: Math.max(usageErr.salience, freeErr.salience), payload: { usage: attentionUsage, focusCount, capacity: effectiveCapacity, freeFraction } });
     }
@@ -5034,7 +5138,18 @@ var StressRegulator = class {
   }
   // ── Engine interface ─────────────────────────────────────
   subscribes() {
-    return ["energy.state.changed", "sleep.state.changed", "novelty.state.changed", "goal.state.changed", "metacognition.state.changed", "executive.prediction.formed"];
+    return [
+      "energy.state.changed",
+      "sleep.state.changed",
+      "novelty.state.changed",
+      "goal.state.changed",
+      "metacognition.state.changed",
+      "executive.prediction.formed",
+      // ACP-P2: our own enactions — the stress swing they cause is expected
+      "agency.enacted",
+      "agency.communicate",
+      "agency.invocation"
+    ];
   }
   publishes() {
     return [];
@@ -5063,8 +5178,17 @@ var StressRegulator = class {
           this._model.setPrecision("stress.load", 1 + p.confidence * 0.5);
         break;
       }
+      case "agency.enacted":
+      case "agency.communicate":
+      case "agency.invocation": {
+        this._model.setPrecision("stress.load", ACP_SELF_PRECISION);
+        this._acpOneShot = true;
+        break;
+      }
     }
   }
+  /** ACP-P2: self-caused stress attenuation armed; react() restores after one observe. */
+  _acpOneShot = false;
   snapshot() {
     return {
       energyLevel: this._energyLevel,
@@ -5157,6 +5281,10 @@ var StressRegulator = class {
     if (_bus) {
       const zoneCode = zone === "low" ? 0 : zone === "optimal" ? 1 : zone === "distress" ? 2 : 3;
       const predErr = this._model.observe("stress.load", newLoad);
+      if (this._acpOneShot) {
+        this._model.setPrecision("stress.load", 1);
+        this._acpOneShot = false;
+      }
       if (!predErr.gated || zone !== previousZone) {
         _bus.publish({ type: "stress.state.changed", version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { load: newLoad, zoneCode, deadlineUrgency: state.metrics.get("deadline.urgency") ?? 0, cognitiveLoad: state.metrics.get("cognitive.load") ?? state.metrics.get("attention.usage") ?? 0 } });
       }
@@ -5379,6 +5507,116 @@ var CircadianOscillator = class {
   }
 };
 
+// src/cognition/agency/consequence.ts
+var CONSEQUENCE_TYPE = "agency.consequence";
+var ATTENUATION = 0.25;
+var MIN_TEXT_MATCH_LEN = 12;
+var CONSEQUENCE_TTL_TICKS = 30;
+function fnv1a(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function paramsKey(value) {
+  if (value === null || typeof value !== "object")
+    return typeof value === "string" ? JSON.stringify(value) : String(value);
+  if (Array.isArray(value))
+    return `[${value.map(paramsKey).join(",")}]`;
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${k}:${paramsKey(obj[k])}`).join(",")}}`;
+}
+function consequenceEntity(d) {
+  return {
+    id: `agency-consequence-${d.intentId}`,
+    type: CONSEQUENCE_TYPE,
+    metadata: { ...d }
+  };
+}
+function readConsequence(m) {
+  const meta = m ?? {};
+  const intentId = typeof meta["intentId"] === "string" ? meta["intentId"] : void 0;
+  const schema = typeof meta["schema"] === "string" ? meta["schema"] : void 0;
+  const mode = meta["mode"] === "communicate" || meta["mode"] === "external" ? meta["mode"] : void 0;
+  if (!intentId || !schema || !mode) return null;
+  return {
+    intentId,
+    schema,
+    mode,
+    effector: typeof meta["effector"] === "string" ? meta["effector"] : void 0,
+    targetEntityId: typeof meta["targetEntityId"] === "string" ? meta["targetEntityId"] : void 0,
+    textHash: typeof meta["textHash"] === "number" ? meta["textHash"] : void 0,
+    text: typeof meta["text"] === "string" ? meta["text"] : void 0,
+    paramsHash: typeof meta["paramsHash"] === "number" ? meta["paramsHash"] : void 0,
+    expiresAt: typeof meta["expiresAt"] === "number" ? meta["expiresAt"] : 0,
+    tick: typeof meta["tick"] === "number" ? meta["tick"] : 0
+  };
+}
+function liveConsequences(entities, tick) {
+  const out = [];
+  for (const [, e] of entities) {
+    if (e.type !== CONSEQUENCE_TYPE) continue;
+    const d = readConsequence(e.metadata);
+    if (d && tick < d.expiresAt) out.push(d);
+  }
+  return out.sort((a, b) => a.intentId < b.intentId ? -1 : a.intentId > b.intentId ? 1 : 0);
+}
+function matchConsequenceText(descriptors, candidate) {
+  if (candidate.length === 0) return null;
+  const candidateHash = fnv1a(candidate);
+  for (const d of descriptors) {
+    if (d.textHash !== void 0 && d.textHash === candidateHash) return d;
+    if (d.text !== void 0 && d.text.length >= MIN_TEXT_MATCH_LEN && candidate.includes(d.text)) return d;
+  }
+  return null;
+}
+var CORRESPONDENCE_ATTENUATION = 0.5;
+function matchConsequenceEntity(descriptors, entityId, changeType) {
+  if (changeType !== "modified" || entityId.length === 0) return null;
+  for (const d of descriptors)
+    if (d.mode === "external" && d.targetEntityId === entityId) return d;
+  return null;
+}
+
+// src/cognition/agency/revocation.ts
+var REVOCATION_TYPE = "agency.revocation";
+var RUPTURE_REVOKE_GATE = 0.7;
+var REVOCATION_TTL_TICKS = 5;
+function revocationId(intentId) {
+  return `agency-revocation-${intentId}`;
+}
+function revocationEntity(intentId, schema, rupture, tick) {
+  return {
+    id: revocationId(intentId),
+    type: REVOCATION_TYPE,
+    metadata: { intentId, schema, rupture, tick, expiresAt: tick + REVOCATION_TTL_TICKS }
+  };
+}
+function revokedIntentIds(entities, tick) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [, e] of entities) {
+    if (e.type !== REVOCATION_TYPE) continue;
+    const m = e.metadata ?? {};
+    const intentId = typeof m["intentId"] === "string" ? m["intentId"] : void 0;
+    const expiresAt = typeof m["expiresAt"] === "number" ? m["expiresAt"] : 0;
+    if (intentId && tick < expiresAt) out.add(intentId);
+  }
+  return out;
+}
+function staleRevocationIds(entities, tick) {
+  const stale = [];
+  for (const [id, e] of entities) {
+    if (e.type !== REVOCATION_TYPE) continue;
+    const m = e.metadata ?? {};
+    const expiresAt = typeof m["expiresAt"] === "number" ? m["expiresAt"] : 0;
+    if (tick >= expiresAt) stale.push(id);
+  }
+  return stale;
+}
+
 // src/cognition/faculties/exteroception.ts
 var internalTypes = /* @__PURE__ */ new Set([
   "percept",
@@ -5404,7 +5642,12 @@ var internalTypes = /* @__PURE__ */ new Set([
   "episodic_memory",
   // Internal state entities written by our own engines — not external events
   "affect.blends",
-  "executive.summary"
+  "executive.summary",
+  // The agency's own forward-model records (EXAFFERENCE P1/P2): perceiving our
+  // expected-consequence descriptors would be a self-noise loop.
+  CONSEQUENCE_TYPE,
+  // The agency's own revocation tombstones (EXAFFERENCE P4) — internal bookkeeping.
+  REVOCATION_TYPE
 ]);
 var Exteroception = class {
   name = "exteroception";
@@ -5454,17 +5697,26 @@ var Exteroception = class {
     const events = [], commands = { set: [], delete: [], metrics: [] };
     const rawPercepts = this._scanWorld(state);
     const capped = rawPercepts.slice(0, this._maxPerceptsPerTick);
+    const consequences = liveConsequences(state.entities, tick);
     for (let i = 0; i < capped.length; i++) {
       const rp = capped[i];
+      const textHit = consequences.length > 0 && rp.matchText ? matchConsequenceText(consequences, rp.matchText) : null;
+      const entityHit = !textHit && consequences.length > 0 ? matchConsequenceEntity(consequences, rp.entityId, rp.changeType) : null;
+      const hit = textHit ?? entityHit;
+      const salience = textHit ? rp.salience * ATTENUATION : entityHit ? rp.salience * CORRESPONDENCE_ATTENUATION : rp.salience;
       const perceptEntity = {
         id: `percept-${tick}-${i}`,
         type: "percept",
         metadata: {
           entityId: rp.entityId,
           changeType: rp.changeType,
-          salience: rp.salience,
+          salience,
           category: rp.category,
           summary: rp.summary,
+          provenance: hit ? "reafferent" : "exafferent",
+          ...hit ? { sourceIntentId: hit.intentId } : {},
+          // affect→percept seam (registry #5): what this percept FEELS like
+          ...rp.valence !== void 0 ? { valence: rp.valence, valenceSource: rp.valenceSource } : {},
           tick
         }
       };
@@ -5475,7 +5727,7 @@ var Exteroception = class {
           source: this.name,
           payload: {
             entityId: rp.entityId,
-            salience: rp.salience,
+            salience,
             category: rp.category,
             summary: rp.summary
           }
@@ -5523,7 +5775,9 @@ var Exteroception = class {
           changeType: "appeared",
           salience: this._computeSalience(entity, "appeared", state.time),
           category: entity.type,
-          summary: this._summarizeEntity(entity, "appeared")
+          summary: this._summarizeEntity(entity, "appeared"),
+          matchText: this._matchText(entity),
+          ...this._valenceOf(id, state)
         });
       } else if (entity.updatedAt > previousVersion) {
         percepts.push({
@@ -5531,7 +5785,9 @@ var Exteroception = class {
           changeType: "modified",
           salience: this._computeSalience(entity, "modified", state.time),
           category: entity.type,
-          summary: this._summarizeEntity(entity, "modified")
+          summary: this._summarizeEntity(entity, "modified"),
+          matchText: this._matchText(entity),
+          ...this._valenceOf(id, state)
         });
       }
       this._previousEntityVersions.set(id, entity.updatedAt);
@@ -5557,6 +5813,46 @@ var Exteroception = class {
    * Generate a meaningful summary for an entity.
    * Instead of "New percept: percept-54-0", produce something useful.
    */
+  /**
+   * The text the corollary-discharge matcher inspects for this entity — its
+   * content (a message body) over its description over its summary. Where our
+   * own delivered words would surface if the world echoes them back.
+   */
+  /**
+   * The affect→percept valence seam (registry #5). A percept carries how the
+   * mind *feels* about what it is a percept OF, resolved most-specific-first:
+   *
+   *   1. the KnownEntityTracker's dossier for this entity (`ke-<id>.valence`) —
+   *      a real per-entity felt valence, the honest signal;
+   *   2. otherwise the ambient `affect.valence` — the felt tone at perception
+   *      time. Weaker evidence, so it is tagged `'ambient'` and consumers
+   *      weight it down (mood is context, not appraisal of this thing).
+   *
+   * Absent both, no valence is stamped and every consumer keeps its
+   * pre-seam behaviour.
+   */
+  /** Spread-friendly form of `_valenceFor` for percept construction. */
+  _valenceOf(entityId, state) {
+    const v = this._valenceFor(entityId, state);
+    return v ? { valence: v.valence, valenceSource: v.source } : {};
+  }
+  _valenceFor(entityId, state) {
+    const dossier = state.entities.get(`ke-${entityId}`);
+    const felt = dossier?.metadata?.["valence"];
+    if (typeof felt === "number" && Number.isFinite(felt))
+      return { valence: felt, source: "entity" };
+    const ambient = state.metrics.get("affect.valence");
+    if (typeof ambient === "number" && Number.isFinite(ambient))
+      return { valence: ambient, source: "ambient" };
+    return void 0;
+  }
+  _matchText(entity) {
+    const m = entity.metadata;
+    const content = typeof m?.["content"] === "string" ? m["content"] : void 0;
+    const description = typeof m?.["description"] === "string" ? m["description"] : void 0;
+    const summary = typeof m?.["summary"] === "string" ? m["summary"] : void 0;
+    return content ?? description ?? summary;
+  }
   _summarizeEntity(entity, changeType) {
     const name = entity.metadata?.name;
     const description = entity.metadata?.description;
@@ -7541,6 +7837,8 @@ var MoralEvaluator = class {
 };
 
 // src/cognition/faculties/affective.blender.ts
+var ACP_AROUSAL_UPLIFT = 0.1;
+var ACP_CONFIDENCE2 = 0.4;
 var DOMINANT_EMOTION_CODES = {
   "neutral": 0,
   "fear": 1,
@@ -7641,6 +7939,8 @@ var AffectiveBlender = class {
   _previousPAD = { valence: 0, arousal: 0.3, dominance: 0.5 };
   _emotionHistory = /* @__PURE__ */ new Map();
   _moodBaseline = 0.5;
+  /** ACP-P2: self-caused arousal attenuation armed; react() restores after one observe. */
+  _acpOneShot = false;
   _energyLevel = 100;
   _comfort = 0.5;
   _sleepPressure = 0;
@@ -7674,8 +7974,12 @@ var AffectiveBlender = class {
       "sleep.state.changed",
       "stress.state.changed",
       "executive.prediction.formed",
-      "interaction.occurred"
+      "interaction.occurred",
       // 2.1: social stimuli drive immediate arousal/valence shifts
+      // ACP-P2: our own enactions — the arousal they cause is expected, not surprising
+      "agency.enacted",
+      "agency.communicate",
+      "agency.invocation"
     ];
   }
   publishes() {
@@ -7684,6 +7988,15 @@ var AffectiveBlender = class {
   onCognitiveEvent(e) {
     this._model.observe(e.type, e.salience);
     switch (e.type) {
+      case "agency.enacted":
+      case "agency.communicate":
+      case "agency.invocation": {
+        const arousal = this._model.predict("affect.arousal");
+        this._model.anticipate("affect.arousal", Math.min(1, arousal + ACP_AROUSAL_UPLIFT), ACP_CONFIDENCE2);
+        this._model.setPrecision("affect.arousal", ACP_SELF_PRECISION);
+        this._acpOneShot = true;
+        break;
+      }
       case "circadian.state.changed":
         this._moodBaseline = e.payload["moodBaseline"] ?? this._moodBaseline;
         break;
@@ -7787,8 +8100,14 @@ var AffectiveBlender = class {
     const _bus = this._bus;
     if (_bus)
       _bus.publish({ type: "affect.state.shifted", version: 1, sourceEngine: this.name, salience: Math.min(1, Math.abs(modulatedPAD.valence) + modulatedPAD.arousal * 0.5), payload: { valence: modulatedPAD.valence, arousal: modulatedPAD.arousal, dominantEmotion: dominant } });
-    if (_bus)
-      _bus.publish({ type: "affect.state.changed", version: 1, sourceEngine: this.name, salience: this._model.observe("affect.arousal", modulatedPAD.arousal).salience, payload: { valence: modulatedPAD.valence, arousal: modulatedPAD.arousal, dominance: modulatedPAD.dominance } });
+    if (_bus) {
+      const arousalErr = this._model.observe("affect.arousal", modulatedPAD.arousal);
+      if (this._acpOneShot) {
+        this._model.setPrecision("affect.arousal", 1);
+        this._acpOneShot = false;
+      }
+      _bus.publish({ type: "affect.state.changed", version: 1, sourceEngine: this.name, salience: arousalErr.salience, payload: { valence: modulatedPAD.valence, arousal: modulatedPAD.arousal, dominance: modulatedPAD.dominance } });
+    }
     return { events: events.length > 0 ? events : void 0, commands };
   }
   // ── PAD computation ──────────────────────────────────────
@@ -16206,7 +16525,8 @@ var TaskSwitcher = class {
         const currentGoal = activeGoals.find((g) => g.id === this._currentFocus.goalId);
         const currentPriority = currentGoal?.priority ?? 0;
         const switchAdvantage = topGoal.priority - currentPriority;
-        const switchCost = this._baseSwitchCost * (1 + this._currentFocus.focusTicks * 0.01);
+        const stability = state.metrics.get("situation.stability") ?? 1;
+        const switchCost = this._baseSwitchCost * (1 + this._currentFocus.focusTicks * 0.01 * stability);
         const netBenefit = switchAdvantage - switchCost;
         if (netBenefit > this._switchThreshold && this._currentFocus.focusTicks >= this._minFocusTicks) {
           this._currentFocus = {
@@ -19807,7 +20127,9 @@ function risk(a, bias) {
   return clamp016(Math.max(0, -a.expectedValence) * 0.5 + bias.threat * 0.5);
 }
 function scoreAffordance(a, bias, w = DEFAULT_WEIGHTS) {
-  return w.goal * goalRelevance(a, bias) + w.reward * a.expectedReward + w.novelty * novelty(a) + w.drive * driveUrgency(a, bias) + w.habit * a.habitStrength + w.plan * (a.planBias ?? 0) - w.cost * a.cost - w.inhib * bias.inhibition - w.risk * risk(a, bias);
+  const raw = w.goal * goalRelevance(a, bias) + w.reward * a.expectedReward + w.novelty * novelty(a) + w.drive * driveUrgency(a, bias) + w.habit * a.habitStrength + w.plan * (a.planBias ?? 0) - w.cost * a.cost - w.inhib * bias.inhibition - w.risk * risk(a, bias);
+  const availability = a.availability ?? 1;
+  return raw > 0 ? raw * availability : raw;
 }
 function stakes(winner, bias) {
   return clamp016(Math.max(
@@ -19886,6 +20208,7 @@ var AffordanceSynthesizer = class {
   // ── react ─────────────────────────────────────────────────────
   async react(_delta, tick, state, _context) {
     this._repertoire?.restoreComposites(state.entities);
+    this._repertoire?.restoreAvailability(state.entities);
     const schemas = this._repertoire?.schemas() ?? this._schemas;
     const skills = this._skills?.() ?? this._repertoire?.skills() ?? null;
     const valence = metric(state, "affect.valence", 0);
@@ -19896,9 +20219,7 @@ var AffordanceSynthesizer = class {
       if (e.type === "affordance") del.push(id);
     const floor = schemas.filter((s) => s.binds === "none");
     for (const schema of floor)
-      set.push(this._toEntity(
-        this._build(schema, tick, state, valence, energyLow, skills, {})
-      ));
+      set.push(this._toEntity(this._build(schema, tick, state, valence, energyLow, skills, {})));
     const candidates = [];
     const goalTargets = collectGoalTargets(state);
     const perceptSchema = schemas.find((s) => s.binds === "percept");
@@ -20013,6 +20334,7 @@ var AffordanceSynthesizer = class {
   /** Compose an Affordance from a schema + the evoking context, folding in learned priors. */
   _build(schema, tick, state, valence, energyLow, skills, ctx) {
     const skill = skills?.get(schema.id);
+    const availability = this._repertoire?.availabilityOf(schema.id) ?? 1;
     const expectedReward = skill?.valueEstimate ?? clamp017(((schema.baseValence ?? 0) + 1) / 2);
     const expectedValence = schema.baseValence ?? valence;
     const habitStrength = skill?.habitStrength ?? 0;
@@ -20034,6 +20356,7 @@ var AffordanceSynthesizer = class {
       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,
@@ -20057,6 +20380,7 @@ var AffordanceSynthesizer = class {
         available: a.available,
         tags: a.tags,
         description: a.description,
+        ...a.availability !== void 0 ? { availability: a.availability } : {},
         planBias: a.planBias,
         planId: a.planId,
         stepId: a.stepId,
@@ -20112,11 +20436,24 @@ var BASE_SWITCH_COST = 0.15;
 var FOCUS_GAIN = 0.01;
 var AWAIT_STALE_TICKS = 15;
 var STALE_DECAY = 0.5;
+var RUPTURE_SALIENCE_GATE = 0.4;
+var RUPTURE_WINDOW_TICKS = 2;
+var STABILITY_RECOVERY = 0.05;
+var STABILITY_EPSILON = 1e-4;
+var REVOKE_HINT_WINDOW = 8;
 var ActionSelector = class {
   name = "action-selector";
   _bus = null;
   _lastEntropy = 0;
   _lastDeliberate = false;
+  // EXAFFERENCE P4 follow-up (Channel B): the schema we most recently revoked
+  // under rupture, so the *next* deliberation formed in its wake can own the
+  // interruption in-character ("something changed — I dropped what I was
+  // weighing"). Telemetry-grade instance state, mirroring _lastEntropy.
+  _lastRevoked = null;
+  // ACP §2b: sense-channel percepts buffered off the bus for the next react's
+  // rupture computation (they never become entities). Cross-tick ⇒ FN9.
+  _senseBuffer = [];
   attachBus(bus) {
     this._bus = bus;
   }
@@ -20124,16 +20461,60 @@ var ActionSelector = class {
     return [
       { type: "agency.selection.made", version: 1, validate: () => null },
       { type: "agency.selection.ambiguous", version: 1, validate: () => null },
-      { type: "agency.action.preempted", version: 1, validate: () => null }
+      { type: "agency.action.preempted", version: 1, validate: () => null },
+      { type: "agency.situation.rupture", version: 1, validate: () => null },
+      { type: "agency.commitment.revoked", version: 1, validate: () => null }
     ];
   }
   subscribes() {
-    return [];
+    return [
+      "senses.*",
+      // Registry #6 (ACP-P3): the model-error term — each carries its
+      // engine's prediction-error salience, ALREADY precision-attenuated for
+      // self-caused swings by the ACP-P2 consumers, so the echo guard
+      // composes by construction: our own action's interoceptive wake
+      // arrives below the rupture gate.
+      "attention.state.changed",
+      "affect.state.changed",
+      "stress.state.changed"
+    ];
   }
-  onCognitiveEvent() {
+  /**
+   * Mostly pull-model — but two afferent classes never become entities and
+   * would leave rupture blind: sense-channel percepts
+   * (ACTION_CONDITIONED_PREDICTION §2b) and the model-error state-change
+   * events (registry #6). Buffer both (cross-tick: bus flush at T, consumed
+   * by react at T+1 — FN9-snapshotted); the echo guard is applied at read
+   * time for texts, and at the SOURCE for model errors (ACP-P2 precision).
+   */
+  onCognitiveEvent(e) {
+    const isSense = e.type.startsWith("senses.") && e.type.endsWith(".percept");
+    const isModelError = e.type === "attention.state.changed" || e.type === "affect.state.changed" || e.type === "stress.state.changed";
+    if (!isSense && !isModelError) return;
+    const p = e.payload;
+    this._senseBuffer.push({
+      salience: e.salience,
+      ...isSense && typeof p?.content === "string" ? { text: p.content } : {}
+    });
   }
   snapshot() {
-    return { lastEntropy: this._lastEntropy, lastDeliberate: this._lastDeliberate };
+    return {
+      lastEntropy: this._lastEntropy,
+      lastDeliberate: this._lastDeliberate,
+      lastRevoked: this._lastRevoked,
+      senseBuffer: this._senseBuffer
+    };
+  }
+  /** FN9: `_lastRevoked` has behavioral effect (the Channel-B `revokedBy` stamp),
+   *  so a restored mind must carry it — a rupture-driven letting-go survives a
+   *  snapshot boundary instead of silently losing its narrative thread. */
+  restore(s) {
+    if (typeof s["lastEntropy"] === "number") this._lastEntropy = s["lastEntropy"];
+    if (typeof s["lastDeliberate"] === "boolean") this._lastDeliberate = s["lastDeliberate"];
+    const lr = s["lastRevoked"];
+    this._lastRevoked = lr && typeof lr === "object" && typeof lr.schema === "string" && typeof lr.tick === "number" ? { schema: lr.schema, tick: lr.tick } : null;
+    const sb = s["senseBuffer"];
+    this._senseBuffer = Array.isArray(sb) ? sb.filter((it) => it && typeof it.salience === "number").map((it) => ({ salience: it.salience, ...typeof it.text === "string" ? { text: it.text } : {} })) : [];
   }
   async react(_delta, tick, state, _context) {
     const eligible = [];
@@ -20162,54 +20543,125 @@ var ActionSelector = class {
     let blocking = false;
     let awaiting = null;
     let composite = null;
+    let deliberating = null;
     for (const it of intents) {
-      if (it.st === "deliberating") blocking = true;
-      else if (it.st === "expanding") composite = { id: it.id, activation: it.activation, schema: it.schema };
+      if (it.st === "deliberating") {
+        blocking = true;
+        deliberating = { id: it.id, schema: it.schema };
+      } else if (it.st === "expanding") composite = { id: it.id, activation: it.activation, schema: it.schema };
       else if (it.st === "awaiting") awaiting = { id: it.id, activation: it.activation, schema: it.schema, target: it.target, dispatchedAt: it.dispatchedAt };
       else if (it.st === "selected") {
         const activeMacroSub = it.parentIntentId !== void 0 && expandingParents.has(it.parentIntentId);
         if (!activeMacroSub) blocking = true;
       }
     }
-    const busy = (n) => ({ commands: { metrics: [
-      ["agency.field.eligible", n],
-      ["agency.selection.busy", 1]
-    ] } });
+    const senseEvents = this._senseBuffer;
+    this._senseBuffer = [];
+    const rupture = computeRupture(state, tick, senseEvents);
+    const prevStab = metric2(state, "situation.stability", 1);
+    const nextStabRaw = clamp018(prevStab + STABILITY_RECOVERY * (1 - prevStab) - rupture);
+    const nextStab = 1 - nextStabRaw < STABILITY_EPSILON ? 1 : nextStabRaw;
+    const stabMetrics = rupture > 0 || prevStab < 1 ? [["situation.stability", nextStab]] : [];
+    if (rupture > 0 && this._bus) {
+      try {
+        this._bus.publish({
+          type: "agency.situation.rupture",
+          version: 1,
+          sourceEngine: this.name,
+          salience: rupture,
+          payload: { rupture, stability: nextStab, tick }
+        });
+      } catch (err) {
+        logger.warn(`[selector] rupture publish failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const busy = (n) => ({
+      commands: {
+        metrics: [
+          ["agency.field.eligible", n],
+          ["agency.selection.busy", 1],
+          ...stabMetrics
+        ]
+      }
+    });
+    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, rupture: revRupture, tick }
+          });
+        } catch (err) {
+          logger.warn(`[selector] revoked publish failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      this._lastRevoked = { schema: deliberating.schema, tick };
+      return {
+        commands: {
+          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]] : [],
+            ...stabMetrics
+          ]
+        }
+      };
+    }
     if (blocking) return busy(eligible.length);
     if (eligible.length === 0)
-      return { commands: { metrics: [["agency.field.eligible", 0], ["agency.selection.busy", awaiting || composite ? 1 : 0]] } };
+      return {
+        commands: {
+          metrics: [
+            ["agency.field.eligible", 0],
+            ["agency.selection.busy", awaiting || composite ? 1 : 0],
+            ...stabMetrics
+          ]
+        }
+      };
     const bias = buildBias(state);
-    const effSwitchCost = effectiveSwitchCost(state);
+    const effSwitchCost = effectiveSwitchCost(state) * (1 - rupture);
     const weights = effectiveWeights(state);
     const scored = eligible.map((a) => ({ affordance: a, activation: scoreAffordance(a, bias, weights) })).sort((x, y) => y.activation - x.activation);
     const winner = scored[0];
     if (!winner) return busy(eligible.length);
+    let compositeTombstone;
+    let compositeFrom;
     if (composite) {
       const different = winner.affordance.schema !== composite.schema;
       const switchCost = effSwitchCost * (1 - stakes(winner.affordance, bias));
-      if (different && winner.activation > composite.activation + switchCost) {
-        if (this._bus) try {
+      if (!different || winner.activation <= composite.activation + switchCost)
+        return busy(eligible.length);
+      if (this._bus)
+        try {
           this._bus.publish({
             type: "agency.action.preempted",
             version: 1,
             sourceEngine: this.name,
             salience: 0.8,
-            payload: { from: composite.schema, to: winner.affordance.schema, activation: winner.activation, tick }
+            payload: {
+              from: composite.schema,
+              to: winner.affordance.schema,
+              activation: winner.activation,
+              tick
+            }
           });
         } catch (err) {
           logger.warn(`[selector] preempt publish failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-        return { commands: { delete: [composite.id], metrics: [
-          ["agency.field.eligible", eligible.length],
-          ["agency.selection.busy", 1],
-          ["agency.selection.preempted", 1]
-        ] } };
-      }
-      return busy(eligible.length);
+      compositeTombstone = composite.id;
+      compositeFrom = composite.schema;
     }
     let preemptDelete;
-    let preemptedFrom;
-    if (awaiting) {
+    let preemptedFrom = compositeFrom;
+    if (awaiting && !compositeTombstone) {
       const sameAction = winner.affordance.schema === awaiting.schema && (winner.affordance.targetEntityId ?? "") === awaiting.target;
       if (sameAction) return busy(eligible.length);
       const staleness = Math.min(1, (tick - awaiting.dispatchedAt) / AWAIT_STALE_TICKS);
@@ -20232,6 +20684,13 @@ var ActionSelector = class {
     const deliberate = margin < marginGate || stk > stakesGate;
     this._lastEntropy = entropy;
     this._lastDeliberate = deliberate;
+    let revokedBy;
+    if (this._lastRevoked) {
+      if (deliberate && tick - this._lastRevoked.tick <= REVOKE_HINT_WINDOW)
+        revokedBy = this._lastRevoked.schema;
+      if (revokedBy || tick - this._lastRevoked.tick > REVOKE_HINT_WINDOW)
+        this._lastRevoked = null;
+    }
     const intent = {
       id: `agency-intent-${tick}`,
       type: "agency.intent",
@@ -20274,6 +20733,9 @@ var ActionSelector = class {
         // interrupted, so the deliberation facet can own the interruption in-character
         // ("I was about to X, but this pulled me away"). Only meaningful while deliberating.
         ...preemptedFrom ? { preemptedFrom } : {},
+        // Channel B: this deliberation forms in the wake of a rupture-driven
+        // revocation — the facet can own "something changed, I let go of X".
+        ...revokedBy ? { revokedBy } : {},
         tick
       }
     };
@@ -20312,7 +20774,9 @@ var ActionSelector = class {
       }
     }
     const commands = {
-      set: [intent],
+      // A composite preemption rides along as a tombstone (never a delete — the
+      // executor's in-tick macro-advance would resurrect the parent).
+      set: compositeTombstone ? [intent, revocationEntity(compositeTombstone, compositeFrom ?? "", rupture, tick)] : [intent],
       ...preemptDelete ? { delete: [preemptDelete] } : {},
       metrics: [
         ["agency.field.eligible", eligible.length],
@@ -20321,7 +20785,8 @@ var ActionSelector = class {
         ["agency.selection.margin", margin],
         ["agency.selection.deliberate", deliberate ? 1 : 0],
         ["agency.selection.preempted", preemptedFrom ? 1 : 0],
-        ["agency.selection.activation", winner.activation]
+        ["agency.selection.activation", winner.activation],
+        ...stabMetrics
       ]
     };
     return { commands };
@@ -20331,7 +20796,40 @@ function effectiveSwitchCost(state) {
   const params = readEffectiveParams(state, "engine-config-action-selector");
   const base = num2(params["switchCost"], BASE_SWITCH_COST);
   const focusTicks = metric2(state, "task_switch.current_focus_ticks", 0);
-  return base * (1 + focusTicks * FOCUS_GAIN);
+  const stability = metric2(state, "situation.stability", 1);
+  return base * (1 + focusTicks * FOCUS_GAIN * stability);
+}
+function computeRupture(state, tick, senseEvents = []) {
+  let maxSalience = 0;
+  for (const e of state.entities.values()) {
+    if (e.type !== "percept") continue;
+    const m = e.metadata;
+    if (str2(m?.["provenance"]) !== "exafferent") continue;
+    const pTick = num2(m?.["tick"], -1);
+    if (pTick < 0 || tick - pTick > RUPTURE_WINDOW_TICKS) continue;
+    const s = num2(m?.["salience"], 0);
+    if (s > maxSalience) maxSalience = s;
+  }
+  if (senseEvents.length > 0) {
+    const live = liveConsequences(state.entities, tick);
+    for (const ev of senseEvents) {
+      if (ev.text !== void 0 && live.length > 0 && matchConsequenceText(live, ev.text)) continue;
+      if (ev.salience > maxSalience) maxSalience = ev.salience;
+    }
+  }
+  if (maxSalience <= RUPTURE_SALIENCE_GATE) return 0;
+  return clamp018((maxSalience - RUPTURE_SALIENCE_GATE) / (1 - RUPTURE_SALIENCE_GATE));
+}
+function refusedClassSchemas(state) {
+  const out = /* @__PURE__ */ new Set();
+  for (const e of state.entities.values()) {
+    if (e.type !== "agency.outcome") continue;
+    const m = e.metadata;
+    if (m?.["refused"] !== true || str2(m?.["finality"]) !== "class") continue;
+    const schema = str2(m?.["schema"]);
+    if (schema) out.add(schema);
+  }
+  return out;
 }
 function effectiveWeights(state) {
   const p = readEffectiveParams(state, "engine-config-action-selector");
@@ -20432,19 +20930,28 @@ var DeliberationEngine = class {
     return { deliberations: this._deliberations };
   }
   async react(_delta, tick, state, _context) {
+    const revoked = revokedIntentIds(state.entities, tick);
+    const del = [];
     let target = null;
     for (const [id2, e] of state.entities) {
       if (e.type !== "agency.intent") continue;
       if (str3(e.metadata?.["status"]) !== "deliberating") continue;
+      if (revoked.has(id2)) {
+        del.push(id2, revocationId(id2));
+        continue;
+      }
       const meta2 = e.metadata ?? {};
       if (!target || id2 < target.id) target = { id: id2, meta: meta2 };
     }
-    if (!target) return { commands: {} };
+    if (!target) return del.length > 0 ? { commands: { delete: del } } : { commands: {} };
     const { id, meta } = target;
     const provisional = str3(meta["schema"]) ?? "wait";
     const candidates = Array.isArray(meta["candidates"]) ? meta["candidates"] : [];
     if (!this._provider)
-      return { commands: { set: [this._commit(id, meta, provisional, candidates, "no-executive")] } };
+      return { commands: {
+        set: [this._commit(id, meta, provisional, candidates, "no-executive")],
+        ...del.length > 0 ? { delete: del } : {}
+      } };
     const chosen = await this._deliberate(state, candidates, provisional, meta);
     this._deliberations++;
     if (this._bus) {
@@ -20462,6 +20969,7 @@ var DeliberationEngine = class {
     return {
       commands: {
         set: [this._commit(id, meta, chosen, candidates, "facet")],
+        ...del.length > 0 ? { delete: del } : {},
         metrics: [["agency.deliberation.count", 1]]
       }
     };
@@ -20519,7 +21027,10 @@ var DeliberationEngine = class {
   _buildFocusContent(state, candidates, meta) {
     const lines = [];
     const preemptedFrom = str3(meta["preemptedFrom"]);
-    if (preemptedFrom)
+    const revokedBy = str3(meta["revokedBy"]);
+    if (revokedBy)
+      lines.push(`Something in my situation just shifted and I let go of what I was weighing ("${revokedBy}"). Decide afresh what to do now:`);
+    else if (preemptedFrom)
       lines.push(`I just broke off a pending action ("${preemptedFrom}") because something more pressing pulled at me. Decide what to do now:`);
     else
       lines.push("My automatic action-selection was uncertain. Candidate actions:");
@@ -20692,8 +21203,22 @@ var MotorSchemaExecutor = class {
     const metrics = [];
     const energy = state.metrics.get("energy.level") ?? 100;
     const stress = state.metrics.get("stress.load") ?? 0;
+    for (const [id, e] of state.entities) {
+      if (e.type !== CONSEQUENCE_TYPE) continue;
+      if (tick >= num3(e.metadata?.["expiresAt"], 0)) del.push(id);
+    }
+    del.push(...staleRevocationIds(state.entities, tick));
+    const revoked = revokedIntentIds(state.entities, tick);
+    if (revoked.size > 0)
+      for (const [id, e] of state.entities) {
+        if (e.type !== "agency.intent") continue;
+        const parentId = str5(e.metadata?.["parentIntentId"]);
+        if (revoked.has(id)) del.push(id, revocationId(id));
+        else if (parentId && revoked.has(parentId)) del.push(id);
+      }
     for (const [id, e] of state.entities) {
       if (e.type !== "agency.intent" || str5(e.metadata?.["status"]) !== "awaiting") continue;
+      if (e.metadata?.["escalated"] === true) continue;
       const dispatchedAt = num3(e.metadata?.["dispatchedAt"], tick);
       if (tick - dispatchedAt < AWAIT_TIMEOUT) continue;
       const intent = readIntent(id, e.metadata);
@@ -20718,6 +21243,9 @@ var MotorSchemaExecutor = class {
     const selected = [...state.entities.entries()].filter(([, e]) => e.type === "agency.intent" && str5(e.metadata?.["status"]) === "selected").sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
     let enactedCount = 0;
     for (const [id, e] of selected) {
+      if (revoked.has(id)) continue;
+      const parentOf = str5(e.metadata?.["parentIntentId"]);
+      if (parentOf && revoked.has(parentOf)) continue;
       const intent = readIntent(id, e.metadata);
       const schema = this._resolve(intent.schema);
       if (schema?.kind === "composite" && schema.composedOf && schema.composedOf.length > 0) {
@@ -20766,6 +21294,18 @@ var MotorSchemaExecutor = class {
               predictedValence: predicted.expectedValence
             }
           });
+          const awaitingText = enaction.mode === "communicate" ? str5(intent.parameters["content"]) ?? firstMessage(intent.parameters["messages"]) : void 0;
+          set.push(consequenceEntity({
+            intentId: id,
+            schema: intent.schema,
+            mode: enaction.mode === "communicate" ? "communicate" : "external",
+            ...enaction.mode === "communicate" ? { effector: COMM_SCHEMA_TO_EFFECTOR[intent.schema] ?? intent.schema } : {},
+            ...intent.targetEntityId ? { targetEntityId: intent.targetEntityId } : {},
+            ...awaitingText ? { text: awaitingText, textHash: fnv1a(awaitingText) } : {},
+            paramsHash: fnv1a(paramsKey(intent.parameters)),
+            expiresAt: tick + CONSEQUENCE_TTL_TICKS,
+            tick
+          }));
           this._emitDispatch(intent, enaction.mode, tick);
           metrics.push([enaction.mode === "communicate" ? "agency.communicate.dispatched" : "agency.invocation.dispatched", 1]);
         }
@@ -20932,6 +21472,18 @@ var MotorSchemaExecutor = class {
     };
     set.push(outcomeEntity(tick, intent, out, predicted));
     del.push(id);
+    if (result.success)
+      set.push(consequenceEntity({
+        intentId: id,
+        schema: intent.schema,
+        mode: "communicate",
+        effector,
+        ...intent.targetEntityId ? { targetEntityId: intent.targetEntityId } : {},
+        textHash: fnv1a(bubbles.join("\n")),
+        text: bubbles.join("\n"),
+        expiresAt: tick + CONSEQUENCE_TTL_TICKS,
+        tick
+      }));
     this._emitEnacted(intent, out, predicted, tick);
     this._emitActionOutcome(
       intent,
@@ -21070,6 +21622,10 @@ function errMsg(err) {
 
 // src/cognition/agency/engines/reafference.engine.ts
 var PROC_THRESHOLD2 = 0.6;
+var SENSORY_SOFT_QUALITY = 0.6;
+var SENSORY_VALENCE_SPAN_ENTITY = 0.25;
+var SENSORY_VALENCE_SPAN_AMBIENT = 0.1;
+var SENSORY_SUCCESS_FLOOR = 0.5;
 var ReafferenceEngine = class {
   name = "reafference";
   _repertoire;
@@ -21119,14 +21675,76 @@ var ReafferenceEngine = class {
     const set = [];
     const del = [];
     const metrics = [];
-    let updates = 0;
-    let discovered = 0;
+    const outcomes = [];
+    const gradedIntentIds = /* @__PURE__ */ new Set();
     for (const [id, e] of state.entities) {
       if (e.type !== "agency.outcome") continue;
       const m = e.metadata ?? {};
+      outcomes.push({ id, meta: m, fromState: true });
+      const iid = str6(m["intentId"]);
+      if (iid) gradedIntentIds.add(iid);
+    }
+    const awaiting = /* @__PURE__ */ new Map();
+    for (const [id, e] of state.entities) {
+      if (e.type !== "agency.intent" || str6(e.metadata?.["status"]) !== "awaiting") continue;
+      const m = e.metadata ?? {};
+      if (tick - num4(m["dispatchedAt"], tick) >= AWAIT_TIMEOUT) continue;
+      awaiting.set(id, {
+        schema: str6(m["schema"]) ?? "",
+        predictedReward: num4(m["predictedReward"], 0.5),
+        predictedValence: num4(m["predictedValence"], 0)
+      });
+    }
+    let sensory = 0;
+    const sensedIntentIds = /* @__PURE__ */ new Set();
+    for (const [, e] of state.entities) {
+      if (e.type !== "percept") continue;
+      const m = e.metadata ?? {};
+      if (str6(m["provenance"]) !== "reafferent") continue;
+      const iid = str6(m["sourceIntentId"]);
+      if (!iid || gradedIntentIds.has(iid) || sensedIntentIds.has(iid)) continue;
+      const aw = awaiting.get(iid);
+      if (!aw || !aw.schema) continue;
+      sensedIntentIds.add(iid);
+      sensory++;
+      const feltRaw = m["valence"];
+      const felt = typeof feltRaw === "number" && Number.isFinite(feltRaw) ? feltRaw : void 0;
+      const span = str6(m["valenceSource"]) === "entity" ? SENSORY_VALENCE_SPAN_ENTITY : SENSORY_VALENCE_SPAN_AMBIENT;
+      const quality = felt === void 0 ? SENSORY_SOFT_QUALITY : clamp0111(SENSORY_SOFT_QUALITY + Math.max(-1, Math.min(1, felt)) * span);
+      outcomes.push({ id: `agency-outcome-${tick}-${iid}-sensory`, fromState: false, meta: {
+        schema: aw.schema,
+        intentId: iid,
+        success: quality >= SENSORY_SUCCESS_FLOOR,
+        outcomeQuality: quality,
+        valence: felt ?? aw.predictedValence,
+        predictedReward: aw.predictedReward,
+        predictedValence: aw.predictedValence,
+        surprise: clamp0111(Math.abs(aw.predictedReward - quality)),
+        mode: "external",
+        reconciled: true,
+        sensory: true,
+        ...felt !== void 0 ? { sensoryValence: felt, valenceSource: str6(m["valenceSource"]) } : {},
+        tick
+      } });
+    }
+    let updates = 0;
+    let discovered = 0;
+    let refused = 0;
+    for (const { id, meta: m, fromState } of outcomes) {
       const schema = str6(m["schema"]);
       if (!schema) {
-        del.push(id);
+        if (fromState) del.push(id);
+        continue;
+      }
+      if (m["refused"] === true) {
+        const finality = str6(m["finality"]) === "class" ? "class" : "instance";
+        this._repertoire.recordRefusal(schema, finality, tick);
+        if (fromState) del.push(id);
+        const refusedIntent = str6(m["intentId"]);
+        if (refusedIntent) del.push(refusedIntent);
+        const refusedPlan = str6(m["planId"]);
+        if (refusedPlan) this._emitPlanOutcome(refusedPlan, str6(m["stepId"]), schema, false, 0, 0, tick);
+        refused++;
         continue;
       }
       const { skill, proceduralized } = this._repertoire.recordOutcome({
@@ -21138,7 +21756,7 @@ var ReafferenceEngine = class {
         tick
       });
       set.push(skillEntity(skill));
-      del.push(id);
+      if (fromState) del.push(id);
       const intentId = str6(m["intentId"]);
       if (intentId) del.push(intentId);
       updates++;
@@ -21155,19 +21773,24 @@ var ReafferenceEngine = class {
       }
     }
     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));
     }
+    for (const id of dropped.availability)
+      del.push(availabilityEntityId(id));
     for (const e of this._repertoire.compositeEntities()) set.push(e);
+    for (const e of this._repertoire.availabilityEntities()) set.push(e);
     const skills = this._repertoire.skills();
     const habitual = [...skills.values()].filter((s) => s.habitStrength >= PROC_THRESHOLD2).length;
     metrics.push(
       ["agency.learning.updates", updates],
       ["agency.discovered.count", discovered],
       ["agency.skill.count", skills.size],
-      ["agency.habitual.count", habitual]
+      ["agency.habitual.count", habitual],
+      ["agency.sensory.confirmed", sensory]
     );
+    if (refused > 0) metrics.push(["agency.refused.count", refused]);
     return { commands: { set, delete: del, metrics } };
   }
   _emitProceduralized(skill, tick) {
@@ -21250,6 +21873,9 @@ function str6(v) {
 function num4(v, fallback) {
   return typeof v === "number" && Number.isFinite(v) ? v : fallback;
 }
+function clamp0111(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
 
 // src/cognition/config.mirror.entities.ts
 function buildEngineConfigEntities(config, executiveInterval) {
@@ -23981,6 +24607,10 @@ var OutboxController = class {
         summary: delivered ? `My message was delivered successfully.` : `My message failed to reach the recipient.`,
         salience: delivered ? 0.35 : 0.6,
         changeType: delivered ? "delivered" : "failed",
+        // Reafference by construction — this percept describes our own action's
+        // outcome ("ear hears the word"). Tagged, not attenuated: it is the ack
+        // surface, not a content echo (EXAFFERENCE P2).
+        provenance: "reafferent",
         messageId
       }
     });
@@ -24382,7 +25012,7 @@ var InboundQueue = class {
 function reconcileInvocation(intentId, schema, result, tick, predicted = { reward: 0.5, valence: 0 }, provenance = {}) {
   const outcomeQuality = result.outcomeQuality ?? (result.success ? 0.8 : 0.1);
   const valence = result.valence ?? (result.success ? 0.2 : -0.2);
-  const surprise = clamp0111(Math.abs(predicted.reward - outcomeQuality));
+  const surprise = clamp0112(Math.abs(predicted.reward - outcomeQuality));
   return {
     id: `agency-outcome-${tick}-${intentId}`,
     type: "agency.outcome",
@@ -24399,17 +25029,66 @@ function reconcileInvocation(intentId, schema, result, tick, predicted = { rewar
       mode: "external",
       tick,
       reconciled: true,
+      ...result.refused ? { refused: true, finality: result.finality ?? "instance" } : {},
       ...provenance.planId ? { planId: provenance.planId } : {},
       ...provenance.stepId ? { stepId: provenance.stepId } : {}
     }
   };
 }
-function clamp0111(n) {
+function clamp0112(n) {
   return n < 0 ? 0 : n > 1 ? 1 : n;
 }
 
+// src/stem/policy/arbiter.ts
+var ALLOW = Object.freeze({ decision: "allow" });
+var NULL_ARBITER = {
+  name: "null",
+  evaluate() {
+    return ALLOW;
+  }
+};
+function isNullArbiter(arbiter) {
+  return !arbiter || arbiter === NULL_ARBITER;
+}
+
+// src/stem/policy/verdict.recorder.ts
+var _sinks3 = /* @__PURE__ */ new Map();
+function getVerdictRecorder(willId) {
+  return _sinks3.get(willId);
+}
+var _sources3 = /* @__PURE__ */ new Map();
+function getVerdictSource(willId) {
+  return _sources3.get(willId);
+}
+
 // src/stem/tracts/effector.controller.ts
+var ESCALATION_TTL_TICKS = 30;
 var effectorController = class {
+  /** The Policy Decision Point consulted before an invocation reaches the world.
+   *  Defaults to the no-op arbiter, so an unconfigured Will is byte-identical. */
+  _arbiter = NULL_ARBITER;
+  /**
+   * Denials queued during a step's flush, drained at the NEXT tick boundary
+   * (POLICY_REAFFERENCE P1). Keyed by willId — harness state, exactly like
+   * `pendingEffectorInvocations`; never simulation state, so it does not touch
+   * `simulation.step` determinism and is regenerated on any re-execution.
+   */
+  _pendingRefusals = /* @__PURE__ */ new Map();
+  /** Escalations awaiting their first application (mark intent + voice the ask). */
+  _newEscalations = /* @__PURE__ */ new Map();
+  /** Escalations currently held, keyed by intent id — the resolvable set. */
+  _activeEscalations = /* @__PURE__ */ new Map();
+  /** Host answers awaiting application at the next tick boundary. */
+  _pendingResolutions = /* @__PURE__ */ new Map();
+  /**
+   * Install a Policy Decision Point (POLICY_REAFFERENCE P0). Passing null
+   * restores the no-op default. The arbiter sees only the proposed act — never
+   * simulation state — and its verdict decides whether the invocation is
+   * handed to the host at all.
+   */
+  setArbiter(arbiter) {
+    this._arbiter = arbiter ?? NULL_ARBITER;
+  }
   /**
    * Update the set of allowed communication effectors at runtime via AccessGrants
    * (the permission / sense gate the senses + reply path read).
@@ -24425,6 +25104,224 @@ var effectorController = class {
    * echoes it on its result-ack, and `confirmExecution` uses it to find the intent.
    */
   bufferInvocation(instance, payload) {
+    const willId = instance.config.id;
+    const source = getVerdictSource(willId);
+    if (source) {
+      const invocation2 = toPolicyInvocation(instance, payload);
+      const record = source.verdictFor(invocation2.tick, invocation2.intentId);
+      if (record) this._applyVerdict(instance, payload, invocation2, recordToVerdict(record));
+      else this._buffer(instance, payload);
+      return;
+    }
+    if (isNullArbiter(this._arbiter)) {
+      this._buffer(instance, payload);
+      return;
+    }
+    const invocation = toPolicyInvocation(instance, payload);
+    let verdict;
+    try {
+      verdict = this._arbiter.evaluate(invocation);
+    } catch (err) {
+      logger.error(`[policy] arbiter "${this._arbiter.name}" threw for "${invocation.schema}" \u2014 failing closed:`, err);
+      return;
+    }
+    if (verdict instanceof Promise) {
+      void verdict.then(
+        (v) => this._recordAndApply(instance, payload, invocation, v),
+        (err) => logger.error(`[policy] arbiter "${this._arbiter.name}" rejected for "${invocation.schema}" \u2014 failing closed:`, err)
+      );
+      return;
+    }
+    this._recordAndApply(instance, payload, invocation, verdict);
+  }
+  /** Capture the verdict on the tape (if a recorder is attached), then enforce it. */
+  _recordAndApply(instance, payload, invocation, verdict) {
+    const sink = getVerdictRecorder(instance.config.id);
+    sink?.recordVerdict({
+      tick: invocation.tick,
+      willId: instance.config.id,
+      intentId: invocation.intentId,
+      schema: invocation.schema,
+      arbiter: this._arbiter.name,
+      decision: verdict.decision,
+      ...verdict.reasonCode ? { reasonCode: verdict.reasonCode } : {},
+      ...verdict.finality ? { finality: verdict.finality } : {},
+      ...verdict.counterfactual ? { counterfactual: verdict.counterfactual } : {},
+      timestamp: Date.now()
+    });
+    this._applyVerdict(instance, payload, invocation, verdict);
+  }
+  /**
+   * Enforce a verdict (POLICY_REAFFERENCE P1).
+   *
+   *   • allow    → hand the invocation to the world.
+   *   • deny     → queue a refusal ack, applied at the next tick boundary via
+   *                `confirmExecution` — the same lifecycle as a host rejection,
+   *                so the mind meets *world resistance*, not a permission dialog.
+   *   • escalate → raise a held escalation (POLICY_REAFFERENCE P4): the intent is
+   *                held (the executor stops timing it out), the Will voices a
+   *                first-person ask once, and a host resolution later approves
+   *                (dispatch) or denies (refuse). Unresolved, it degrades to a
+   *                refusal at ESCALATION_TTL_TICKS.
+   *
+   * P1's refusal reconciles as a plain FAILURE — safe, but the wrong learning
+   * signal (forbidden ≠ unskilled). P2 routes it to affordance AVAILABILITY
+   * instead of competence.
+   */
+  _applyVerdict(instance, payload, invocation, verdict) {
+    if (verdict.decision === "allow") {
+      this._buffer(instance, payload);
+      return;
+    }
+    const cf = verdict.counterfactual;
+    logger.info(
+      `[policy] ${verdict.decision.toUpperCase()} "${invocation.schema}" intent "${invocation.intentId}" \u2014 ${verdict.reasonCode ?? "no reason code"}` + (verdict.finality ? ` (${verdict.finality})` : "") + (cf ? ` [${cf.field}: requested ${JSON.stringify(cf.requested)}, allowed ${JSON.stringify(cf.allowed)}]` : "")
+    );
+    if (verdict.decision === "deny") {
+      const queue = this._pendingRefusals.get(instance.config.id) ?? [];
+      queue.push({
+        intentId: invocation.intentId,
+        schema: invocation.schema,
+        reasonCode: verdict.reasonCode ?? "POLICY_DENIED",
+        finality: verdict.finality ?? "instance"
+      });
+      this._pendingRefusals.set(instance.config.id, queue);
+      return;
+    }
+    const escalations = this._newEscalations.get(instance.config.id) ?? [];
+    escalations.push({
+      intentId: invocation.intentId,
+      schema: invocation.schema,
+      reasonCode: verdict.reasonCode ?? "APPROVAL_REQUIRED",
+      payload,
+      expiresAt: 0
+      // stamped when applied (we don't have the current tick here)
+    });
+    this._newEscalations.set(instance.config.id, escalations);
+  }
+  /**
+   * Record a host's answer to an escalation (POLICY_REAFFERENCE P4). Applied at
+   * the next tick boundary so every simulation-state write stays on the boundary:
+   * approve dispatches the held invocation to the world; deny refuses it. A
+   * no-op if the intent id is not (or no longer) an active escalation.
+   */
+  resolveEscalation(instance, intentId, approved) {
+    const queue = this._pendingResolutions.get(instance.config.id) ?? [];
+    queue.push({ intentId, approved });
+    this._pendingResolutions.set(instance.config.id, queue);
+  }
+  /**
+   * Apply queued policy refusals as failure acks (POLICY_REAFFERENCE P1).
+   * Called by the tick loop at the same boundary as inbound acks — BEFORE the
+   * step, stamped to this tick — so a denial reconciled here is the exact
+   * lifecycle of a host rejection that arrived between ticks.
+   */
+  applyPolicyOutcomes(instance) {
+    const tick = instance.tickCount;
+    this._applyResolutions(instance);
+    this._expireEscalations(instance, tick);
+    this._applyNewEscalations(instance, tick);
+    this._applyRefusals(instance);
+  }
+  /** Drain queued refusals into failure acks (POLICY_REAFFERENCE P1). */
+  _applyRefusals(instance) {
+    const queue = this._pendingRefusals.get(instance.config.id);
+    if (!queue || queue.length === 0) return;
+    this._pendingRefusals.set(instance.config.id, []);
+    for (const refusal of queue)
+      this.confirmExecution(instance, refusal.intentId, {
+        success: false,
+        refused: true,
+        finality: refusal.finality === "class" ? "class" : "instance",
+        description: `refused by policy: ${refusal.reasonCode} (${refusal.finality})`
+      });
+  }
+  /** Raise each newly-escalated intent (POLICY_REAFFERENCE P4): mark it held in
+   *  simulation state, voice the ask ONCE, and move it to the resolvable set. */
+  _applyNewEscalations(instance, tick) {
+    const pending = this._newEscalations.get(instance.config.id);
+    if (!pending || pending.length === 0) return;
+    this._newEscalations.set(instance.config.id, []);
+    const active = this._activeEscalations.get(instance.config.id) ?? /* @__PURE__ */ new Map();
+    for (const esc of pending) {
+      esc.expiresAt = tick + ESCALATION_TTL_TICKS;
+      this._markEscalated(instance, esc.intentId, esc.expiresAt);
+      this._voiceEscalation(instance, esc);
+      active.set(esc.intentId, esc);
+    }
+    this._activeEscalations.set(instance.config.id, active);
+  }
+  /** Apply host answers to active escalations (POLICY_REAFFERENCE P4). */
+  _applyResolutions(instance) {
+    const queue = this._pendingResolutions.get(instance.config.id);
+    if (!queue || queue.length === 0) return;
+    this._pendingResolutions.set(instance.config.id, []);
+    const active = this._activeEscalations.get(instance.config.id);
+    for (const { intentId, approved } of queue) {
+      const esc = active?.get(intentId);
+      if (!esc) continue;
+      active.delete(intentId);
+      this._clearEscalated(instance, intentId);
+      if (approved) {
+        this._buffer(instance, esc.payload);
+        logger.info(`[policy] escalation APPROVED \u2192 dispatching "${esc.schema}" intent "${intentId}"`);
+      } else {
+        this._queueRefusal(instance, esc.intentId, esc.schema, esc.reasonCode, "class");
+        logger.info(`[policy] escalation DENIED \u2192 refusing "${esc.schema}" intent "${intentId}"`);
+      }
+    }
+  }
+  /** Degrade escalations no one answered in time into instance-refusals (P4). */
+  _expireEscalations(instance, tick) {
+    const active = this._activeEscalations.get(instance.config.id);
+    if (!active || active.size === 0) return;
+    for (const [intentId, esc] of active) {
+      if (tick < esc.expiresAt) continue;
+      active.delete(intentId);
+      this._clearEscalated(instance, intentId);
+      this._queueRefusal(instance, esc.intentId, esc.schema, "ESCALATION_EXPIRED", "instance");
+      logger.info(`[policy] escalation EXPIRED \u2192 refusing "${esc.schema}" intent "${intentId}"`);
+    }
+  }
+  /** Push a refusal onto the queue drained by _applyRefusals this same tick. */
+  _queueRefusal(instance, intentId, schema, reasonCode, finality) {
+    const queue = this._pendingRefusals.get(instance.config.id) ?? [];
+    queue.push({ intentId, schema, reasonCode, finality });
+    this._pendingRefusals.set(instance.config.id, queue);
+  }
+  /** Mark the awaiting intent held: the executor stops timing it out (P4). */
+  _markEscalated(instance, intentId, expiresAt) {
+    const intent = instance.simulation.stateManager.snapshot().entities.get(intentId);
+    if (!intent || intent.type !== "agency.intent") return;
+    instance.simulation.stateManager.setEntity({
+      id: intent.id,
+      type: intent.type,
+      metadata: { ...intent.metadata ?? {}, escalated: true, escalationExpiresAt: expiresAt }
+    });
+  }
+  /** Release the hold so the executor resumes normal timeout for this intent. */
+  _clearEscalated(instance, intentId) {
+    const intent = instance.simulation.stateManager.snapshot().entities.get(intentId);
+    if (!intent || intent.type !== "agency.intent") return;
+    const meta = { ...intent.metadata ?? {} };
+    delete meta["escalated"];
+    delete meta["escalationExpiresAt"];
+    instance.simulation.stateManager.setEntity({ id: intent.id, type: intent.type, metadata: meta });
+  }
+  /** Voice the escalation as a first-person broadcast ask — once, at raise time. */
+  _voiceEscalation(instance, esc) {
+    try {
+      instance.cognition.outboxWriter.enqueue({
+        targetEntityId: "*",
+        content: escalationAsk(esc.schema, esc.reasonCode),
+        effectorName: "broadcast"
+      });
+    } catch (err) {
+      logger.warn(`[policy] escalation voice failed for "${esc.schema}": ${errMsg2(err)}`);
+    }
+  }
+  /** Queue an approved invocation for the delivery layer. */
+  _buffer(instance, payload) {
     const intentId = payload.intentId ?? "";
     instance.pendingEffectorInvocations.push({
       id: intentId,
@@ -24499,6 +25396,38 @@ var effectorController = class {
 function num5(v, fallback) {
   return typeof v === "number" && Number.isFinite(v) ? v : fallback;
 }
+function escalationAsk(schema, reasonCode) {
+  const meaning = ESCALATION_MEANINGS[reasonCode] ?? "I need your approval before I can do this";
+  return `I want to ${schema}, but ${meaning}. May I go ahead?`;
+}
+var ESCALATION_MEANINGS = {
+  APPROVAL_REQUIRED: "I need your approval before I can on my own",
+  WRITE_REQUIRES_APPROVAL: "it writes to the world and I shouldn't on my own",
+  PAYMENT_REQUIRES_APPROVAL: "it moves money and I must not do that unattended",
+  DEPLOY_REQUIRES_APPROVAL: "it ships something and needs a human to sign off"
+};
+function errMsg2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function recordToVerdict(record) {
+  return {
+    decision: record.decision,
+    ...record.reasonCode ? { reasonCode: record.reasonCode } : {},
+    ...record.finality ? { finality: record.finality } : {},
+    ...record.counterfactual ? { counterfactual: record.counterfactual } : {}
+  };
+}
+function toPolicyInvocation(instance, payload) {
+  return {
+    willId: instance.config.id,
+    intentId: payload.intentId ?? "",
+    schema: payload.schema ?? "",
+    parameters: payload.parameters ?? {},
+    ...typeof payload.targetEntityId === "string" ? { targetEntityId: payload.targetEntityId } : {},
+    ...typeof payload.description === "string" ? { description: payload.description } : {},
+    tick: payload.tick ?? 0
+  };
+}
 
 // src/stem/tracts/sensory.controller.ts
 var SensoryController = class {
@@ -25301,6 +26230,15 @@ var WillStem = class {
   confirmEffectorExecution(id, invocationId, result) {
     this._effector.confirmExecution(this._get(id), invocationId, result);
   }
+  /**
+   * Resolve a policy escalation the Will raised (POLICY_REAFFERENCE P4).
+   * `approved` dispatches the held invocation to the world; otherwise it is
+   * refused. Applied at the next tick boundary. `invocationId` is the awaiting
+   * `agency.intent` id the escalation ask referenced.
+   */
+  resolveEscalation(id, invocationId, approved) {
+    this._effector.resolveEscalation(this._get(id), invocationId, approved);
+  }
   // ── Messaging / outbox (11.1) ────────────────────────────────────────────
   // Delegates to OutboxController (R5-c). `_get(id)` validates the Will exists
   // and supplies the WillInstance; the outbox ops touch only instance fields.
@@ -25431,6 +26369,7 @@ var WillStem = class {
         outbox: this._outbox,
         sensory: this._sensory
       });
+      this._effector.applyPolicyOutcomes(instance);
       await instance.simulation.step(1);
       instance.tickCount++;
       instance.lastTickAt = /* @__PURE__ */ new Date();