dsh-biocore 0.3.1 → 0.3.2

package/python/biocore_runtime/pipeline.py

@@ -120,6 +120,20 @@ except Exception:  # pragma: no cover
         from biocore_runtime import relationship_state as _relationship_state
     except Exception:
         _relationship_state = None
+try:  # task-225: P0 memory + expression extensions
+    from . import extensions as _extensions
+except Exception:  # pragma: no cover
+    try:
+        from biocore_runtime import extensions as _extensions
+    except Exception:
+        _extensions = None
+try:  # task-224: P0 perception/relationship/self signals
+    from . import signals as _signals
+except Exception:  # pragma: no cover
+    try:
+        from biocore_runtime import signals as _signals
+    except Exception:
+        _signals = None
 try:  # task-222: self layer + autonomy
     from . import self_layer as _self_layer
 except Exception:  # pragma: no cover
@@ -438,6 +452,21 @@ def _concept_filter(entries, query):
     return narrowed or rows
 
 
+def _signals_eval(store, session_id, user_text="", assistant_text="",
+                  state=None, now=None):
+    if _signals is None or not store:
+        return None
+    try:
+        rel = (relationship_read(store)["relationship"]
+               if _store_root(store) is not None else {})
+        return _signals.evaluate(store, session_id=session_id,
+                                 user_text=user_text,
+                                 assistant_text=assistant_text,
+                                 state=state or {}, relationship=rel, now=now)
+    except Exception:
+        return None
+
+
 def _governance_tick(store, now=None):
     """Decay/index/graph/aggregate sidecars; never deletes a memory."""
     if _governance is None or not store:
@@ -670,6 +699,7 @@ def inject_block(session_id, store, max_chars=MAX_CHARS, top_k=TOP_K,
     text_query = clean_text(query, MAX_TEXT_CHARS)
     chosen = str(mode or "query").strip().lower()
     entries = []
+    query_used = False
     if chosen == "query" and text_query:
         try:
             picked = _query_entries(store, session_id, text_query, limit,
@@ -678,11 +708,24 @@ def inject_block(session_id, store, max_chars=MAX_CHARS, top_k=TOP_K,
             picked = None
         if picked:
             entries = list(picked)
+            query_used = True
     if not entries:
         entries = sorted(_visible(load_memory(store, session_id).get("entries")),
                          key=lambda entry: (1 if entry.get("pin") else 0,
                                             _num(entry.get("ts"), 0.0)),
                          reverse=True)[:limit]
+    if (query_used and text_query and entries and _extensions is not None):
+        try:
+            all_entries = _visible(load_memory(store, session_id).get("entries"))
+            ext = _extensions.expand_recall(
+                store, all_entries, text_query,
+                [str(entry.get("id") or "") for entry in entries])
+            for row in ext.get("extra") or []:
+                if row not in entries:
+                    entries.append(row)
+            entries = entries[:max(limit, min(limit + 2, INJECT_MAX_K))]
+        except Exception:
+            pass
     header = "你记得这些事："
     ids = []
     if not entries or budget <= len(header) + 3:
@@ -824,6 +867,22 @@ def prompt_block(payload):
     state_text = _state_block(state, budget)
     constraints = _constraints_block(state, switches, data)
     text = (state_text + "\n" + constraints).strip()
+    expression = None
+    if _extensions is not None:
+        try:
+            target = _int_param(data.get("length_target"), 0, 0, 400)
+            hard = _int_param(data.get("length_max"), 0, 0, 400)
+            expression = _extensions.expression_block(
+                data.get("store"), state, data.get("relationship"),
+                soft_target=target, soft_max=hard)
+            extra = [value for value in (expression.get("rules"),
+                                         expression.get("template"),
+                                         expression.get("topic"),
+                                         expression.get("voice")) if value]
+            if extra:
+                text = text + "\n" + "\n".join("- " + line for line in extra[:4])
+        except Exception:
+            expression = None
     thinking_line = thinking_style_line(data)
     persona_line = persona_prompt_line(data)
     if thinking_line:
@@ -833,6 +892,8 @@ def prompt_block(payload):
     sections = {"state": state_text, "constraints": constraints}
     if thinking_line:
         sections["thinking_style"] = thinking_line
+    if expression:
+        sections["expression"] = expression
     if persona_line:
         sections["persona"] = persona_line
     return {"ok": True, "phase": phase, "text": text, "chars": len(text),
@@ -2166,11 +2227,25 @@ def _ui_state_body(store, session_id, data):
                 "limits": _autonomy.limits(store)}
         except Exception:
             autonomy_view = None
+    signals_summary = None
+    if _signals is not None:
+        try:
+            signals_summary = _signals.summary(store)
+        except Exception:
+            signals_summary = None
+    extensions_summary = None
+    if _extensions is not None:
+        try:
+            extensions_summary = _extensions.extension_summary(store)
+        except Exception:
+            extensions_summary = None
     identity = {"v": round(_num(core.get("v"), 0.0), 2),
                 "intero": intero,
                 "governance": governance_summary,
                 "relationship_summary": relationship_summary,
                 "identity": identity_summary,
+                "signals": signals_summary,
+                "extensions": extensions_summary,
                 "available": True,
                 "session_id": sanitize_session_id(session_id),
                 "memory_count": len(entries),
@@ -2476,6 +2551,8 @@ def dispatch(action, payload=None):
                                                       data.get("state"))
             if state_store is not None:
                 _save_session_state(state_store, session_id, session_state)
+            _signals_eval(store, session_id, user_text=user_text,
+                          state=session_state, now=time.time())
             capture_enabled = _as_bool(data.get("capture"), True)
             captured_user = {"captured": False, "entry_id": "", "reason": "disabled"}
             capture_store = data.get("store")
@@ -2607,6 +2684,51 @@ def dispatch(action, payload=None):
             governance_info = _governance_tick(store, now=time.time())
             relationship_info = _relationship_tick(
                 store, data.get("user_text"), now=time.time())
+            signals_end = _signals_eval(
+                store, session_id,
+                user_text=str(data.get("user_text") or ""),
+                assistant_text=assistant_text,
+                state=(_load_session_state(store, session_id)
+                       if store is not None else {}),
+                now=time.time())
+            if _extensions is not None:
+                try:
+                    all_entries = _visible(
+                        load_memory(store, session_id).get("entries"))
+                    picked_ids = [str(row.get("id") or "")
+                                  for row in all_entries[:5]]
+                    commitment = ((signals_end or {}).get("relationship", {})
+                                  .get("commitment_extractor") or {})
+                    if commitment.get("has_commitment"):
+                        _extensions.add_commitment(
+                            store, str(commitment.get("what") or ""),
+                            float(commitment.get("due_ts") or 0.0),
+                            now=time.time())
+                    expression = _extensions.expression_block(
+                        store, _load_session_state(store, session_id),
+                        (relationship_read(store)["relationship"]
+                         if store is not None else {}))
+                    snapshot = {
+                        "graph": {"entities": 0, "edges": 0},
+                        "layered": _extensions.layered_view(all_entries,
+                                                            picked_ids),
+                        "prospective": _extensions.prospective_view(
+                            store, time.time()),
+                        "reconstruction": _extensions.reconstruction_view(
+                            all_entries),
+                        "turn_memory": _extensions.turn_memory_view(
+                            [{"entry_id": row.get("id"),
+                              "text": row.get("text"), "source": "recall"}
+                             for row in all_entries[:5]],
+                            reply=assistant_text, now=time.time()),
+                        "expression": expression,
+                    }
+                    hits, graph_stats = _extensions.graph_hits(
+                        all_entries, str(data.get("user_text") or ""))
+                    snapshot["graph"] = graph_stats
+                    _extensions.record_extension_snapshot(store, snapshot)
+                except Exception:
+                    pass
             identity_info = None
             if relationship_info:
                 identity_info = _identity_tick(
@@ -2677,11 +2799,18 @@ def dispatch(action, payload=None):
                                      "limits": _autonomy.limits(store)}
                 except Exception:
                     autonomy_info = None
+            signals_info = None
+            if _signals is not None:
+                try:
+                    signals_info = _signals.summary(store)
+                except Exception:
+                    signals_info = None
             return {"ok": True, "embed": embed, "switches": out,
                     "governance": governance_info,
                     "relationship": relationship_info,
                     "identity": identity_info,
                     "autonomy": autonomy_info,
+                    "signals": signals_info,
                     "store": str(store)}
         if action == "autonomy_tick":
             return _autonomy_tick(store, data) or {

package/python/biocore_runtime/signals.py

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+"""task-224 (5a): P0 perception / relationship / self modules wired into the core.
+
+One deterministic snapshot per turn, stored at <dataDir>/signals.json and
+exposed through /state. Every module call is guarded: a missing or failing
+module yields {"enabled": false, "reason": ...} instead of breaking a turn.
+No LLM, no IO beyond the one sidecar file.
+"""
+from __future__ import annotations
+
+import importlib
+import json
+import time
+from pathlib import Path
+
+import biocore_model as _bm
+
+SIGNALS_FILE = "signals.json"
+HISTORY_LIMIT = 50
+SCHEMA = 1
+
+PERCEPTION = ("affective_labor", "compassion_fatigue", "connection_bids",
+              "defense_mechanisms", "emotion_geometry", "needs_events",
+              "social_pain", "social_repair")
+RELATIONSHIP = ("commitment_extractor", "relation_stage",
+                "relationship_stage", "repair_after_boundary")
+SELF = ("metacog", "possible_selves", "self_interest", "self_verification")
+
+
+def _root(store):
+    if isinstance(store, dict):
+        raw = store.get("root") or store.get("store") or store.get("path")
+    else:
+        raw = store
+    text = str(raw or "").strip()
+    return Path(text) if text else None
+
+
+def _data_dir(store):
+    root = _root(store)
+    return (root.parent if root.name == "memory" else root) if root else None
+
+
+def _read(path):
+    try:
+        if path is None or not path.exists():
+            return {}
+        doc = json.loads(path.read_text(encoding="utf-8"))
+        return doc if isinstance(doc, dict) else {}
+    except Exception:
+        return {}
+
+
+def _write(path, doc):
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(path.name + ".tmp")
+        tmp.write_text(json.dumps(doc, ensure_ascii=False, indent=2),
+                       encoding="utf-8")
+        tmp.replace(path)
+        return True
+    except Exception:
+        return False
+
+
+def _mod(name):
+    module = getattr(_bm, name, None)
+    if module is not None:
+        return module
+    try:
+        return importlib.import_module("biocore_model." + name)
+    except Exception:
+        try:
+            return importlib.import_module("." + name, package="biocore_model")
+        except Exception:
+            return None
+
+
+def _call(name, fn, *args, **kwargs):
+    module = _mod(name)
+    if module is None or not callable(getattr(module, fn, None)):
+        return {"enabled": False, "reason": "module_missing"}
+    try:
+        value = getattr(module, fn)(*args, **kwargs)
+        return {"enabled": True, "value": value}
+    except Exception as error:
+        return {"enabled": False, "reason": type(error).__name__}
+
+
+def evaluate(store, session_id="s1", user_text="", assistant_text="",
+             state=None, relationship=None, now=None):
+    """Run all 17 P0 modules once; never raises."""
+    stamp = round(float(now or time.time()), 3)
+    core = state.get("core") if isinstance(state, dict) and isinstance(
+        state.get("core"), dict) else (state if isinstance(state, dict) else {})
+    rel = relationship if isinstance(relationship, dict) else {}
+    v = float(core.get("v") or 0.0)
+    a = float(core.get("a") or 0.5)
+    stress = float(core.get("stress") or 0.2)
+    social = float(core.get("social") or 0.55)
+    text = str(user_text or "")
+
+    out = {"schema": SCHEMA, "ts": stamp, "session_id": str(session_id),
+           "enabled": {}, "perception": {}, "relationship": {}, "self": {}}
+
+    # --- perception ---------------------------------------------------
+    labor = _call("affective_labor", "turn_cost", max(0.0, min(1.0, (v + 1) / 2)),
+                  max(0.0, min(1.0, (v + 1) / 2)), 0.0)
+    out["perception"]["affective_labor"] = labor
+    out["enabled"]["affective_labor"] = labor["enabled"]
+
+    fatigue = _call("compassion_fatigue", "fatigue", 0, max(0.0, -v), 0.0)
+    out["perception"]["compassion_fatigue"] = fatigue
+    out["enabled"]["compassion_fatigue"] = fatigue["enabled"]
+
+    recorded = _call("connection_bids", "record_bid", [], stamp, "user")
+    bid_items = recorded.get("value") if isinstance(recorded.get("value"), list) else []
+    settled = _call("connection_bids", "settle_bids", bid_items, stamp)
+    view = _call("connection_bids", "bid_view", bid_items, 1.0)
+    out["perception"]["connection_bids"] = {
+        "enabled": recorded["enabled"], "bids": len(bid_items),
+        "settled": len(settled.get("value") or []) if isinstance(
+            settled.get("value"), list) else 0,
+        "view": view.get("value")}
+    out["enabled"]["connection_bids"] = recorded["enabled"]
+
+    defense = _call("defense_mechanisms", "assess",
+                    {"kind": "message", "valence": v, "intensity": abs(v)},
+                    {"valence": v, "arousal": a, "stress": stress})
+    out["perception"]["defense_mechanisms"] = defense
+    out["enabled"]["defense_mechanisms"] = defense["enabled"]
+
+    geometry = _call("emotion_geometry", "classify",
+                     {"v": v, "a": a, "stress": stress})
+    out["perception"]["emotion_geometry"] = geometry
+    out["enabled"]["emotion_geometry"] = geometry["enabled"]
+
+    needs = _call("needs_events", "needs_state",
+                  {"social": social, "energy": core.get("energy", 0.6),
+                   "stress": stress})
+    out["perception"]["needs_events"] = needs
+    out["enabled"]["needs_events"] = needs["enabled"]
+
+    pain = _call("social_pain", "update", {"value": 0.0},
+                 "rejection" if v < -0.3 or rel.get("conflict", 0) > 0.2
+                 else "neutral", stamp)
+    pain_view = _call("social_pain", "view", pain.get("value") or {"value": 0.0})
+    out["perception"]["social_pain"] = {
+        "enabled": pain["enabled"], "view": pain_view.get("value")}
+    out["enabled"]["social_pain"] = pain["enabled"]
+
+    repair = _call("social_repair", "repair_check", text, "")
+    empathy = _call("social_repair", "empathy", v)
+    out["perception"]["social_repair"] = {
+        "enabled": repair["enabled"], "repair": repair.get("value"),
+        "empathy": empathy.get("value")}
+    out["enabled"]["social_repair"] = repair["enabled"]
+
+    # --- relationship -------------------------------------------------
+    commitment = _call("commitment_extractor", "extract", text, None, stamp)
+    value = commitment.get("value") if isinstance(commitment.get("value"), dict) else {}
+    out["relationship"]["commitment_extractor"] = {
+        "enabled": commitment["enabled"],
+        "has_commitment": bool(value.get("has_commitment")),
+        "what": str(value.get("what") or ""),
+        "due_ts": value.get("due_ts"),
+        "value": value}
+    out["enabled"]["commitment_extractor"] = commitment["enabled"]
+
+    stage = _call("relation_stage", "evaluate",
+                  {"valence": v, "stress": stress, "relationship": rel})
+    out["relationship"]["relation_stage"] = stage
+    out["enabled"]["relation_stage"] = stage["enabled"]
+
+    hours = float(rel.get("days_known", 0) or 0) * 24.0
+    stage_word = _call("relationship_stage", "stage_for", hours)
+    out["relationship"]["relationship_stage"] = stage_word
+    out["enabled"]["relationship_stage"] = stage_word["enabled"]
+
+    boundary = _call("repair_after_boundary", "evaluate", None, 0.0, None)
+    out["relationship"]["repair_after_boundary"] = boundary
+    out["enabled"]["repair_after_boundary"] = boundary["enabled"]
+
+    # --- self ---------------------------------------------------------
+    band = _call("metacog", "evaluate", None,
+                 max(0.0, min(1.0, 1.0 - abs(v))), 0,
+                 bool(rel.get("conflict", 0) > 0.3))
+    out["self"]["metacog"] = band
+    out["enabled"]["metacog"] = band["enabled"]
+
+    selves = _call("possible_selves", "rank", None,
+                   {"valence": v, "stress": stress})
+    out["self"]["possible_selves"] = selves
+    out["enabled"]["possible_selves"] = selves["enabled"]
+
+    interest = _call("self_interest", "assess",
+                     {"valence": v, "social": social,
+                      "relationship": rel, "needs": core.get("needs")})
+    out["self"]["self_interest"] = interest
+    out["enabled"]["self_interest"] = interest["enabled"]
+
+    verify = _call("self_verification", "observe", {"misread": 0.0},
+                   0.0, 0.6, float(rel.get("trust", 0.5) or 0.5))
+    verify_intent = _call("self_verification", "intent",
+                          verify.get("value") or {"value": 0.0})
+    out["self"]["self_verification"] = {
+        "enabled": verify["enabled"], "state": verify.get("value"),
+        "intent": verify_intent.get("value")}
+    out["enabled"]["self_verification"] = verify["enabled"]
+
+    out["counts"] = {
+        "perception": len(out["perception"]),
+        "relationship": len(out["relationship"]),
+        "self": len(out["self"]),
+        "enabled": sum(1 for value in out["enabled"].values() if value),
+    }
+    _record(store, session_id, out)
+    return out
+
+
+def _record(store, session_id, snapshot):
+    path = (_data_dir(store) or Path(".")) / SIGNALS_FILE
+    doc = _read(path)
+    history = [row for row in (doc.get("history") or []) if isinstance(row, dict)]
+    history.append(snapshot)
+    doc.update({"schema": SCHEMA, "ts": snapshot["ts"],
+                "session_id": str(session_id),
+                "history": history[-HISTORY_LIMIT:],
+                "latest": snapshot})
+    _write(path, doc)
+
+
+def summary(store):
+    """Read-only snapshot for /state (never recomputes)."""
+    doc = _read((_data_dir(store) or Path(".")) / SIGNALS_FILE)
+    latest = doc.get("latest") if isinstance(doc.get("latest"), dict) else {}
+    if not latest:
+        return {"enabled": {name: False for name in
+                            PERCEPTION + RELATIONSHIP + SELF},
+                "perception": {}, "relationship": {}, "self": {},
+                "counts": {"perception": 0, "relationship": 0, "self": 0,
+                           "enabled": 0}}
+    return latest