poseres 2.2.0__tar.gz → 2.3.0__tar.gz

{poseres-2.2.0/src/poseres.egg-info → poseres-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poseres
-Version: 2.2.0
+Version: 2.3.0
 Summary: Pose Resolution Architecture — validation harness and batched in-memory core
 Author: Daan Gerits
 License: Copyright (c) 2026 Daan Gerits

{poseres-2.2.0 → poseres-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "poseres"
-version = "2.2.0"
+version = "2.3.0"
 description = "Pose Resolution Architecture — validation harness and batched in-memory core"
 readme = "README.md"
 # >=3.12 since feature 013: ROS 2 LTS containers bind rclpy to Ubuntu 24.04's

{poseres-2.2.0 → poseres-2.3.0/src/poseres.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poseres
-Version: 2.2.0
+Version: 2.3.0
 Summary: Pose Resolution Architecture — validation harness and batched in-memory core
 Author: Daan Gerits
 License: Copyright (c) 2026 Daan Gerits

{poseres-2.2.0 → poseres-2.3.0}/src/pra/action/recipe.py

@@ -13,6 +13,19 @@ held at bar, 20/24 provably recipe-led.
 Recipes are policy-side state, deliberately not snapshot state in v1: they
 are reconstructible from kept demonstrations (the feature-041 spec records
 the assumption).
+
+Place-keyed futility (feature 045; the-long-carry, episode 0120): without
+a disconfirmation pathway the selection argmax is stateless and the body
+pressed a closed gate for 4,672 of 6,000 life-steps. The measured repair
+(rig prototype K=200/W=800: parking abolished, the revive-peek-wander
+loop emerged, first brain-driven lap crossings) ships here keyed to the
+PLACE — a stalled pointer poisons the quantized subgoal it points at, and
+every recipe currently pointing there is ineligible together until the
+poison expires. Both refuted forms carried numbers: per-recipe erosion
+thrashed at the poison boundary (556 die/revive events in one life) and
+per-recipe hysteresis fell back through the cohort of near-identical
+recipes. Futility state follows the recipe rule above: policy-side, not
+snapshot state.
 """
 
 from __future__ import annotations
@@ -82,6 +95,20 @@ class RecipePolicy(CompletionItchPolicy):
     added terms are inert and the policy degrades to its parent. Bounded
     watch counters: ``advance_events`` (subgoal pointer progress) and
     ``out_of_context`` (no recipe step within 2 blocks — the parrot watch).
+
+    Place-keyed futility (feature 045; episode 0120 measured, module
+    docstring): with ``futility_k > 0``, ``futility_k`` consecutive
+    followed steps without pointer advance poison the pointed place —
+    the subgoal position rounded to the block grid — for ``futility_w``
+    selection steps; recipes whose pointer currently resolves to a
+    poisoned place are ineligible, and with none eligible the policy is
+    exactly its parent (the wander phase). Expiry is a clean peek: the
+    stall count restarts, so re-poisoning takes ``futility_k`` fresh
+    steps — the re-check cadence comes from the constants alone. The
+    ONLY futility state is per-place (both per-recipe forms are the
+    measured failure modes); ``futility_k = 0`` (default) is bit-exact
+    pre-045 behavior, RNG stream included. Watch counters:
+    ``fatigue_events`` (poisons created), ``revive_events`` (expired).
     """
 
     def __init__(
@@ -102,6 +129,8 @@ class RecipePolicy(CompletionItchPolicy):
         deficit_kappa: float = 0.0,
         commit_kappa: float = 0.0,
         explore_defers_holds: bool = False,
+        futility_k: int = 0,
+        futility_w: int = 800,
     ):
         super().__init__(
             params,
@@ -121,9 +150,21 @@ class RecipePolicy(CompletionItchPolicy):
         self.lambda_r = float(lambda_r)
         self.position_indices = (int(position_indices[0]), int(position_indices[1]))
         self.position_scale = float(position_scale)
+        fk, fw = float(futility_k), float(futility_w)
+        if not np.isfinite(fk) or fk < 0.0 or fk != int(fk):
+            raise ValueError(f"RecipePolicy: futility_k {futility_k} must be a finite integer >= 0")
+        if not np.isfinite(fw) or fw <= 0.0 or fw != int(fw):
+            raise ValueError(f"RecipePolicy: futility_w {futility_w} must be a finite integer > 0")
+        self.futility_k = int(fk)
+        self.futility_w = int(fw)
         self.advance_events = 0
         self.out_of_context = 0
+        self.fatigue_events = 0
+        self.revive_events = 0
         self._prev_ptr = -1
+        self._futility_step = 0
+        self._poisons: dict[tuple[int, int], int] = {}  # place -> last poisoned step
+        self._stall: tuple[tuple[int, int], int] | None = None  # (place, count)
         self._ctx: PolicyContext | None = None
         self._subgoal: tuple[float, float] | None = None
         self.potential_of = self._recipe_hold
@@ -132,10 +173,45 @@ class RecipePolicy(CompletionItchPolicy):
         ix, iz = self.position_indices
         return float(obs[ix]) * self.position_scale, float(obs[iz]) * self.position_scale
 
+    def _place_key(self, pos: tuple[float, float]) -> tuple[int, int]:
+        return int(round(pos[0])), int(round(pos[1]))
+
+    def _pointed_place(self, ctx: PolicyContext, recipe: Recipe) -> tuple[int, int]:
+        """Where this recipe's pointer currently resolves — the
+        side-effect-free twin of :meth:`_point_subgoal`'s arithmetic."""
+        cur = self._pos(ctx.observation)
+        dists = [
+            max(abs(self._pos(o)[0] - cur[0]), abs(self._pos(o)[1] - cur[1])) for o in recipe.steps
+        ]
+        ptr = min(int(np.argmin(dists)) + 1, len(recipe.steps) - 1)
+        return self._place_key(self._pos(recipe.steps[ptr]))
+
+    def _expire_poisons(self) -> None:
+        for place in [p for p, last in self._poisons.items() if last < self._futility_step]:
+            del self._poisons[place]
+            self.revive_events += 1
+
+    def _track_stall(self, place: tuple[int, int], advanced: bool) -> None:
+        if advanced:
+            self._stall = None
+            return
+        count = self._stall[1] + 1 if self._stall is not None and self._stall[0] == place else 1
+        if count >= self.futility_k:
+            # dead through step + futility_w inclusive: exactly futility_w
+            # ineligible selection steps, then the peek
+            self._poisons[place] = self._futility_step + self.futility_w
+            self._stall = None
+            self.fatigue_events += 1
+        else:
+            self._stall = (place, count)
+
     def _select_recipe(self, ctx: PolicyContext) -> Recipe | None:
         best, best_v = None, -np.inf
         weight = 0.0 if self.label_index is None else self._label_weight(ctx.observation)
+        poisons = self._poisons if self.futility_k else None
         for r in self.memory.recipes:
+            if poisons and self._pointed_place(ctx, r) in poisons:
+                continue
             v = ctx.drive_value_of(r.terminal)
             if self.label_index is not None:
                 v += weight * float(r.terminal[self.label_index])
@@ -171,6 +247,12 @@ class RecipePolicy(CompletionItchPolicy):
 
     def select_action(self, context: PolicyContext, rng) -> int:
         self._ctx = context
+        if self.futility_k:
+            self._futility_step += 1
+            self._expire_poisons()
+        adv_before = self.advance_events
         recipe = self._select_recipe(context)
         self._subgoal = None if recipe is None else self._point_subgoal(context, recipe)
+        if self.futility_k and self._subgoal is not None:
+            self._track_stall(self._place_key(self._subgoal), self.advance_events > adv_before)
         return super().select_action(context, rng)

{poseres-2.2.0 → poseres-2.3.0}/src/pra/anatomy/minecraft/anatomy.py

@@ -149,12 +149,26 @@ _AIM = SensorSpec(
     labels=tuple(f"s{k}" for k in range(8)) + ("drop",),
 )
 
+# The peers sense (research topic lean-worlds, licensed by Bar L1,
+# 2026-08-17): the nearest OTHER body, in the drops sense's exact
+# grammar — presence, egocentric bearing, distance, count, and the
+# appearance signature of the world's own username (identity as
+# property; hashed, never parsed). Opt-in; appended LAST so every
+# shipped offset is unchanged.
+_PEERS = SensorSpec(
+    id="peers",
+    topic="peers",
+    width=8,
+    labels=("present", "sin_b", "cos_b", "dist", "count", "sig0", "sig1", "sig2"),
+)
+
 
 def c1_anatomy(
     crafting: bool = True,
     survival: bool | None = None,
     flood: bool | None = None,
     aim: str | None = None,
+    peers: bool = False,
 ) -> tuple[list[SensorSpec], list[ActuatorSpec]]:
     """The (sensors, actuators) lists `Ros2Body.factory` expects.
 
@@ -167,7 +181,9 @@ def c1_anatomy(
     ``crafting=False``: the exact feature-027 body (14/8).
     ``flood=True``/``aim="worth"``: the instrument senses individually
     (module doc); ``aim="salience"`` is bridge behavior only, the
-    declaration byte-identical to ``aim=""``.
+    declaration byte-identical to ``aim=""``. ``peers=True`` appends
+    the peers sense LAST (research topic lean-worlds; ships into the
+    default only on promotion) — the 94/13 instrument body.
     """
     if survival is None:
         blessed = crafting  # the zero-override default: design 0015's stack
@@ -189,6 +205,8 @@ def c1_anatomy(
         raise ValueError(f"unknown aim form {aim!r}: expected '', 'salience', or 'worth'")
     if aim and not survival:
         raise ValueError("the aim is a survival-instrument sense: it needs the distal body")
+    if peers and not survival:
+        raise ValueError("the peers sense is a survival-instrument sense: it needs the distal body")
     sensors = list(_BASE_SENSORS) + (list(_PROPERTY_SENSORS) if crafting else [])
     if survival:
         sensors = [_SURVIVAL_HAND if s.id == "hand" else s for s in sensors]
@@ -197,6 +215,8 @@ def c1_anatomy(
         sensors.append(_FLOOD)
     if aim == "worth":
         sensors.append(_AIM)
+    if peers:
+        sensors.append(_PEERS)
     presets = _BASE_PRESETS + (_GRID_PRESETS if crafting else ())
     presets += _SURVIVAL_PRESETS if survival else ()
     return sensors, [ActuatorSpec(id="control", topic="control", presets=presets)]