From 0e6dada09b57310ecd4437dd961dd469a8a98d41 Mon Sep 17 00:00:00 2001 From: Shay Date: Wed, 8 Jul 2026 07:26:03 -0700 Subject: [PATCH] chore(cleanup): complete post-pickup hygiene, consolidation, and review fixes for 3lang depth unification - Remove retired HANDOFF-antigravity-2026-07-01.md stray. - Harden enrich_assessments_with_depth (remove fragile __dict__ fallback; best-effort only). - Explicit _last_node_depths in ChatRuntime; clean direct propagation from pipeline (remove hasattr/setattr dance + bare excepts). - Add clarifying propagation contract comments. - Update plan.md with cleanup section. - All targeted tests + SHA/claims checks green post-edit. - Tree clean, ready to roll. Addresses remaining MEDIUM items from code-reviewer run. --- chat/runtime.py | 3 ++- core/cognition/pipeline.py | 12 +++++++----- plan.md | 12 ++++++++++++ recognition/depth_canonical.py | 20 ++++++++------------ 4 files changed, 29 insertions(+), 18 deletions(-) diff --git a/chat/runtime.py b/chat/runtime.py index 2c15b623..defd5fdf 100644 --- a/chat/runtime.py +++ b/chat/runtime.py @@ -608,6 +608,7 @@ class ChatRuntime: pack_ids = tuple(config.input_packs) self.config = resolved_config + self._last_node_depths: dict | None = None # 3-lang PropGraph depth propagation (he/grc roots) to contemplate paths; set by pipeline manifests = [] manifolds = [] entries = [] @@ -889,7 +890,7 @@ class ChatRuntime: if self.config.auto_contemplate and candidates_to_save: from teaching.contemplation import contemplate vault_probe = _vault_probe_for_context(self._context) if self._context else None - depth = getattr(self, '_last_node_depths', None) # from PropGraph for 3-lang + depth = getattr(self, '_last_node_depths', None) # from pipeline PropGraph depth (3-lang root propagation contract) candidates_to_save = [ contemplate(c, vault_probe=vault_probe, depth=depth) for c in candidates_to_save diff --git a/core/cognition/pipeline.py b/core/cognition/pipeline.py index 5a4fdc84..0017bf4c 100644 --- a/core/cognition/pipeline.py +++ b/core/cognition/pipeline.py @@ -495,19 +495,21 @@ class CognitiveTurnPipeline: oov_geometric_context = {} oov_geometric_context["graph_anti_unify"] = graph_anti_unify(topo, node_depths) except Exception: + # Best-effort telemetry only; anti-unify failure must not affect main path. pass # Capture depths (post-enrich) to attrs for recognize chaining (AC1) + runtime contemplate depth= (real). + # Propagation contract (3-lang depth on PropGraph spine): pipeline (after OOV/PropGraph construction) + # writes to runtime so that runtime.contemplate() and teaching paths can forward it without + # re-resolving packs. This is the current minimal cross-component channel; see review notes for + # future narrowing via explicit DepthCarrier or context object. if node_depths: self._current_node_depths = node_depths if effective_graph and effective_graph.nodes: self._current_agent_node_id = effective_graph.nodes[0].node_id self._last_node_depths = node_depths - if hasattr(self.runtime, "_last_node_depths"): - try: - setattr(self.runtime, "_last_node_depths", node_depths) - except Exception: - pass + # Direct assignment now that runtime explicitly declares the attr (cleanup of hasattr/setattr dance) + self.runtime._last_node_depths = node_depths # Track last node id for correction-intent chaining if graph.nodes: diff --git a/plan.md b/plan.md index c723fd97..d64d08a8 100644 --- a/plan.md +++ b/plan.md @@ -102,3 +102,15 @@ All skeptic gaps addressed (pipeline recog/ctx/attrs, runtime depth pass, teachi - Next if more R&D: extend root-aware to additional construction/derivation call sites for 3lang frames; add he/grc construction exemplars; wire depth into more geometric proposal paths; prep PR (push to forgejo remote, use tea pulls). - Invariants re-confirmed: immutability (replace/new), exact, no drift repair, fresh trace stable, core lanes green. - Pickup seeds (NEW_SESSION_PROMPT.txt, docs/session-compacts/2026-07-06-compact.md, COMPACT_STRATEGY.md) can now be archived per strategy. + +## 2026-07-08 Cleanup, Consolidation & Hygiene (post-pickup) +- Tree fully cleaned: retired HANDOFF-antigravity stray removed from legacy/. +- Addressed remaining code-review MEDIUM items (minimal targeted changes): + - `recognition/depth_canonical.py`: removed risky `__dict__` reconstruction fallback in `enrich_assessments_with_depth`. Now pure best-effort via `replace`; on failure keeps original (safer for frozen/slots ContractAssessment post-CGA). + - `chat/runtime.py`: explicit `self._last_node_depths = None` declaration in `__init__`. + - `core/cognition/pipeline.py`: direct assignment for depth propagation (removed hasattr/setattr/try dance); added clear contract comment; improved graph_anti_unify best-effort comment. +- Duplication already consolidated (get_node_depths delegates to build_node_depths). +- Verifs post-cleanup: spine/anti/depth/construction key tests 35+ passed; SHA pins match canonical reports; claims test green (9/9 overall). +- All changes small, preserve immutability + invariants, no behavior change for 3-lang paths. +- Branch ready: clean working tree, on top of latest forgejo/main, conventional history, documented. +- No other stray artifacts, .gitkeeps, or report cruft introduced by this slice. diff --git a/recognition/depth_canonical.py b/recognition/depth_canonical.py index d2e286de..d4a6ae6b 100644 --- a/recognition/depth_canonical.py +++ b/recognition/depth_canonical.py @@ -91,9 +91,12 @@ def build_node_depths(nodes: Sequence[Any]) -> dict[str, dict]: def enrich_assessments_with_depth(assessments: Tuple[Any, ...], depth: dict | None) -> Tuple[Any, ...]: - """Immutable enrichment of assessments with root note using dataclasses.replace if possible. + """Immutable enrichment of assessments with root note using dataclasses.replace. - Returns new tuple, no mutation of input. + Returns a new tuple. Enrichment is best-effort: if an assessment does not + support replace (e.g. non-dataclass or frozen in an incompatible way), the + original item is kept without the depth note. No __dict__ reconstruction + is performed (avoids producing invalid objects for slots/frozen types). """ if not depth: return assessments @@ -107,16 +110,9 @@ def enrich_assessments_with_depth(assessments: Tuple[Any, ...], depth: dict | No try: new_a = replace(a, explanation=(getattr(a, "explanation", "") or "") + note) except Exception: - # create copy for annotation (avoid mutate original/frozen) - try: - if hasattr(a, '__dict__'): - new_a = type(a)(**a.__dict__) - if hasattr(new_a, 'explanation'): - new_a.explanation = (getattr(new_a, 'explanation', '') or '') + note - else: - new_a = a - except Exception: - new_a = a + # Best-effort only; do not synthesize copies that could violate + # frozen/slots invariants after CGA substrate types. + new_a = a new_ass.append(new_a) else: new_ass.append(a)