dsh-biocore 0.1.0 → 0.1.2

package/python/biocore_model/graph_recall.py

@@ -0,0 +1,221 @@
+# -*- coding: utf-8 -*-
+"""Graph recall -> "你知道的" prompt block + panel data (task-136).
+
+Read-only: match entity names/aliases in the current message, walk 1-2 hops
+in the SQLite entity graph, rank edges by recency and confidence, and render
+at most five lines. A time window ("上周"/"昨天"/"三天前") restricts edges to
+that window. panel_data() feeds the Graph dashboard page.
+"""
+from __future__ import annotations
+
+import json
+import time
+
+from . import entity_graph as _eg
+from . import graph_extract as _gx
+
+MAX_LINES = 5
+MAX_ENTITIES = 3
+MAX_EDGES = 200
+
+WINDOW_WORDS = {
+    "上周": 7, "上星期": 7, "上礼拜": 7, "最近一周": 7, "这周": 7,
+    "本周": 7, "这星期": 7, "昨天": 1, "昨日": 1, "前天": 2,
+    "三天内": 3, "最近三天": 3, "上个月": 30, "上月": 30,
+}
+
+
+def detect_window(text, now=None):
+    """Return (window_days, label) for a relative time phrase, else (None, "")."""
+    del now
+    value = " ".join(str(text or "").split())
+    for word, days in WINDOW_WORDS.items():
+        if word in value:
+            return int(days), word
+    return None, ""
+
+
+def _fmt_ts(ts):
+    number = float(ts or 0.0)
+    if number <= 0:
+        return ""
+    try:
+        return time.strftime("%m-%d %H:%M", time.localtime(number))
+    except Exception:
+        return ""
+
+
+def _rel_score(edge, now):
+    try:
+        confidence = float(edge.get("confidence", 0.0) or 0.0)
+    except Exception:
+        confidence = 0.0
+    try:
+        ts = float(edge.get("ts", 0.0) or 0.0)
+    except Exception:
+        ts = 0.0
+    if ts <= 0 or now <= 0:
+        recency = 0.0
+    else:
+        age_days = max(0.0, (now - ts) / 86400.0)
+        recency = 1.0 / (1.0 + age_days / 7.0)
+    return round(0.65 * confidence + 0.35 * recency, 4)
+
+
+def _name_of(by_id, entity_id):
+    row = by_id.get(entity_id)
+    if isinstance(row, dict):
+        return str(row.get("name") or "")
+    return ""
+
+
+def recall(store, text, now=None, hops=2, limit=MAX_LINES,
+           window_days=None, window_label=""):
+    """Rank graph edges around matched entities -> list of prompt rows."""
+    del window_label
+    stamp = float(now if now is not None else time.time())
+    entities = _eg.search(store, text, limit=MAX_ENTITIES)
+    if not entities:
+        return []
+    try:
+        cap = max(1, min(MAX_LINES, int(limit)))
+    except Exception:
+        cap = MAX_LINES
+    if window_days is None:
+        window_days, _label = detect_window(text, stamp)
+    by_id = {entity["id"]: entity for entity in entities}
+    candidate_edges = []
+    seen_edges = set()
+    for entity in entities:
+        walked = _eg.neighbors(store, entity["name"], hops=hops,
+                               window_days=window_days, now=stamp)
+        for row in walked.get("entities") or []:
+            by_id.setdefault(row["id"], row)
+        for edge in walked.get("edges") or []:
+            eid = str(edge.get("id") or "")
+            if not eid or eid in seen_edges:
+                continue
+            seen_edges.add(eid)
+            candidate_edges.append(edge)
+    rows = []
+    for edge in candidate_edges[:MAX_EDGES]:
+        src_name = _name_of(by_id, edge.get("src"))
+        dst_name = _name_of(by_id, edge.get("dst"))
+        if not src_name or not dst_name:
+            continue
+        relation = str(edge.get("rel") or "")
+        line = "%s —%s→ %s" % (src_name, _gx.rel_label(relation), dst_name)
+        when = _fmt_ts(edge.get("ts"))
+        if when:
+            line += "（%s）" % when
+        source_entity = by_id.get(edge.get("src")) or {}
+        target_entity = by_id.get(edge.get("dst")) or {}
+        rows.append({"edge_id": edge.get("id"), "line": line,
+                     "src": src_name, "dst": dst_name, "rel": relation,
+                     "rel_label": _gx.rel_label(relation),
+                     "ts": float(edge.get("ts", 0.0) or 0.0),
+                     "confidence": float(edge.get("confidence", 0.0) or 0.0),
+                     "score": _rel_score(edge, stamp),
+                     "src_type": source_entity.get("type"),
+                     "dst_type": target_entity.get("type"),
+                     "source_entry": str(edge.get("source_entry") or "")})
+    rows.sort(key=lambda row: (row["score"], row["ts"]), reverse=True)
+    return rows[:cap]
+
+
+def render(store, text, now=None, limit=MAX_LINES):
+    """Return the "你知道的" block (<=5 lines) or an empty string."""
+    try:
+        rows = recall(store, text, now=now, limit=limit)
+    except Exception:
+        return ""
+    if not rows:
+        return ""
+    lines = ["你知道的："]
+    for row in rows:
+        lines.append("- " + str(row["line"]))
+    return "\n".join(lines[:max(1, min(MAX_LINES, int(limit))) + 1])
+
+
+def _row_entity_public(row):
+    def _json_list(raw):
+        try:
+            value = json.loads(raw or "[]")
+        except Exception:
+            return []
+        return [str(x) for x in value if str(x)] if isinstance(value, list) else []
+
+    kind = str(row[2] or "topic")
+    return {"id": row[0], "name": row[1], "type": kind,
+            "type_label": _gx.type_label(kind),
+            "aliases": _json_list(row[3]),
+            "first_seen": float(row[4] or 0.0),
+            "last_seen": float(row[5] or 0.0),
+            "sources": _json_list(row[6])}
+
+
+def timeline(store, entity, now=None, window_days=None, limit=12):
+    """Edges touching one entity, newest first (panel detail / time view)."""
+    stamp = float(now if now is not None else time.time())
+    try:
+        cap = max(1, min(50, int(limit)))
+    except Exception:
+        cap = 12
+    walked = _eg.neighbors(store, entity, hops=1, window_days=window_days,
+                           now=stamp)
+    by_id = {row["id"]: row for row in walked.get("entities") or []}
+    rows = []
+    for edge in walked.get("edges") or []:
+        src_name = _name_of(by_id, edge.get("src"))
+        dst_name = _name_of(by_id, edge.get("dst"))
+        rows.append({"edge_id": edge.get("id"),
+                     "text": "%s —%s→ %s" % (
+                         src_name, _gx.rel_label(edge.get("rel")), dst_name),
+                     "when": _fmt_ts(edge.get("ts")),
+                     "ts": float(edge.get("ts", 0.0) or 0.0),
+                     "confidence": float(edge.get("confidence", 0.0) or 0.0)})
+    rows.sort(key=lambda row: row["ts"], reverse=True)
+    return rows[:cap]
+
+
+def panel_data(store, now=None, limit_entities=100, limit_edges=400):
+    """Flat entity/edge snapshot consumed by the dashboard Graph page."""
+    stamp = float(now if now is not None else time.time())
+    try:
+        entity_cap = max(1, min(500, int(limit_entities)))
+        edge_cap = max(1, min(2000, int(limit_edges)))
+    except Exception:
+        entity_cap, edge_cap = 100, 400
+    entities = [_row_entity_public(row) for row in store._conn.execute(
+        "SELECT id, name, type, aliases, first_seen, last_seen, sources "
+        "FROM entities ORDER BY last_seen DESC LIMIT ?",
+        (entity_cap,)).fetchall()]
+    by_id = {row["id"]: row for row in entities}
+    edges = []
+    for row in store._conn.execute(
+            "SELECT id, src, rel, dst, ts, confidence, source_entry "
+            "FROM edges ORDER BY ts DESC LIMIT ?", (edge_cap,)).fetchall():
+        edges.append({"id": row[0], "src": row[1], "dst": row[3],
+                      "src_name": (by_id.get(row[1]) or {}).get("name", ""),
+                      "dst_name": (by_id.get(row[3]) or {}).get("name", ""),
+                      "rel": row[2], "rel_label": _gx.rel_label(row[2]),
+                      "ts": float(row[4] or 0.0),
+                      "when": _fmt_ts(row[4]),
+                      "confidence": float(row[5] or 0.0),
+                      "source_entry": row[6] or ""})
+    try:
+        stats = _eg.stats(store)
+    except Exception:
+        stats = {"entities": len(entities), "edges": len(edges)}
+    return {"stats": stats, "entities": entities, "edges": edges,
+            "now": stamp}
+
+
+def source_entries(edges):
+    """Collect source entry ids for the panel's "related entries" column."""
+    seen = []
+    for edge in edges or []:
+        value = str((edge or {}).get("source_entry") or "")
+        if value and value not in seen:
+            seen.append(value)
+    return seen

package/python/biocore_model/intent_render.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+"""HUMAN-6 intent rendering: feeling -> tendency constraint, no raw signals.
+
+Turns an internal action/feeling into one short tendency line for the
+interpretation layer. Hard constraints: no digits, no emotion words, no
+diagnostic labels -- only a behavioural inclination plus optional tone/guard
+fragments that are themselves sanitized.
+
+Literature
+  Barrett 2017 (language constrains constructed emotion), Craig 2009
+  (interoception precedes words), Seth 2013 (prediction -> action tendency),
+  Powers 1973 (perceptual control error becomes action), Carver & Scheier 1998
+  (approach/withdraw tendencies), Gross 1998 (regulation strategy phrasing),
+  Garfinkel 2015 (sensibility vs accuracy), Sterling 2012 (allostatic action).
+
+Constraints: pure functions, stdlib only, no IO, no main import.
+"""
+from __future__ import annotations
+
+import re
+
+PHRASES = {
+    "approach": "想靠近一点",
+    "share": "想和你说说话",
+    "question": "想先问清楚",
+    "withdraw": "想先退开一点",
+    "repair": "想把气氛缓一缓",
+    "rest": "想安静一会儿",
+}
+FALLBACK = "想待一会儿"
+FORBIDDEN_EMOTION_WORDS = (
+    "开心", "高兴", "快乐", "难过", "伤心", "悲伤", "生气", "愤怒", "恼火",
+    "害怕", "恐惧", "焦虑", "紧张", "孤独", "寂寞", "压力", "情绪", "心情",
+    "抑郁", "烦躁", "崩溃", "委屈", "内疚", "羞耻",
+)
+DIGIT_RE = re.compile(r"[0-9０-９]+")
+PUNCT_RE = re.compile(r"[，,。；;、\s]+")
+
+
+def _clean_fragment(value):
+    text = str(value or "")
+    text = DIGIT_RE.sub("", text)
+    for word in FORBIDDEN_EMOTION_WORDS:
+        text = text.replace(word, "")
+    return PUNCT_RE.sub(" ", text).strip(" ，,。；;、")
+
+
+def check(text):
+    """Return {ok, digits, emotion_words} for one candidate line."""
+    value = str(text or "")
+    digits = DIGIT_RE.findall(value)
+    words = [word for word in FORBIDDEN_EMOTION_WORDS if word in value]
+    return {"ok": not digits and not words, "digits": digits, "emotion_words": words}
+
+
+def sanitize(text, fallback=FALLBACK):
+    value = _clean_fragment(text)
+    if not value:
+        value = fallback
+    return value
+
+
+def render(intent, tone=None, guard=None):
+    """Render one tendency line: action phrase + optional tone/guard."""
+    action = ""
+    if isinstance(intent, dict):
+        action = str(intent.get("action") or "")
+    elif intent:
+        action = str(intent)
+    phrase = PHRASES.get(action, FALLBACK)
+    parts = [phrase]
+    tone_text = _clean_fragment(tone)
+    if tone_text:
+        parts.append(tone_text)
+    guard_text = _clean_fragment(guard)
+    if guard_text:
+        parts.append(guard_text)
+    text = "，".join(parts)
+    text = sanitize(text)
+    result = check(text)
+    return text if result["ok"] else sanitize(text)
+
+
+def tendency(intent):
+    """Coarse approach/withdraw label for downstream stages (no words)."""
+    action = ""
+    if isinstance(intent, dict):
+        action = str(intent.get("action") or "")
+    return {"approach": "approach", "share": "approach", "question": "approach",
+            "repair": "approach", "withdraw": "withdraw", "rest": "withdraw"}.get(
+                action, "neutral")

package/python/biocore_model/intero_core.py

@@ -0,0 +1,235 @@
+# -*- coding: utf-8 -*-
+"""L0 interoception core: four non-verbal body dimensions in [0, 1].
+
+These values are computed from body/affect state only -- never inferred from
+text -- so the biological layer keeps owning "how the body feels" while the
+interpretation layer owns language.
+
+Dimensions
+  tension   (绷紧): stress/arousal load, sleep debt, relationship conflict
+  warmth    (暖)  : valence baseline, social saturation, trust, closeness
+  heaviness (沉)  : sadness, allostatic load, low energy, loneliness
+  clarity   (清)  : inverse noise, restedness, arousal near the middle
+
+Literature
+  Craig 2009 (insula interoception), Barrett 2017 (constructed emotion),
+  Seth 2013 (interoceptive prediction), Garfinkel 2015 (three-dimensional
+  interoception: accuracy/sensibility/awareness), Sterling 2012 (allostasis),
+  Carver & Scheier 1998 (cybernetic control), Powers 1973 (perceptual
+  control), Gross 1998 (emotion regulation strategies).
+
+Hard constraints: pure functions, stdlib only, no IO, no main import, time is
+injected (now=), and update() is idempotent for the same now. The core state
+object is never mutated -- callers pass a dict and get a fresh dict back.
+"""
+from __future__ import annotations
+
+import math
+
+DIMS = ("tension", "warmth", "heaviness", "clarity")
+
+# Set-points / comfort band (Gross 1998 regulation targets; Sterling 2012).
+COMFORT = {"tension": 0.30, "warmth": 0.60, "heaviness": 0.30, "clarity": 0.70}
+BAND = {"tension": 0.15, "warmth": 0.20, "heaviness": 0.15, "clarity": 0.20}
+WEIGHTS = {"tension": 0.30, "warmth": 0.25, "heaviness": 0.25, "clarity": 0.20}
+
+# Defaults keep the formulas total and monotone even on partial state dicts.
+DEFAULTS = {
+    "stress": 0.0, "arousal": 0.5, "sleep_debt": 0.0, "conflict": 0.0,
+    "v": 0.0, "social": 0.5, "trust": 0.5, "closeness": 0.5,
+    "sadness": 0.0, "allostatic_load": 0.0, "energy": 0.55,
+    "loneliness": 0.0, "noise": 0.0,
+}
+
+
+def _clamp(value, lo=0.0, hi=1.0):
+    try:
+        return max(lo, min(hi, float(value)))
+    except Exception:
+        return lo
+
+
+def _num(source, key, default=0.0):
+    if not isinstance(source, dict):
+        return float(default)
+    try:
+        value = source.get(key, default)
+        if value is None:
+            return float(default)
+        return float(value)
+    except Exception:
+        return float(default)
+
+
+def _noise_value(source):
+    """Noise may be a scalar or the core per-channel noise dict."""
+    if not isinstance(source, dict):
+        return 0.0
+    value = source.get("noise", 0.0)
+    if isinstance(value, dict) and value:
+        try:
+            return _clamp(sum(abs(float(v)) for v in value.values()) / len(value))
+        except Exception:
+            return 0.0
+    return _clamp(value)
+
+
+def _labels(source):
+    if not isinstance(source, dict):
+        return {}
+    labels = source.get("labels")
+    return labels if isinstance(labels, dict) else {}
+
+
+def _emotion(source):
+    labels = _labels(source)
+    return str(labels.get("emotion") or source.get("emotion") or "neutral")
+
+
+def inputs(state=None):
+    """Extract the formula inputs from a core snapshot / state dict.
+
+    Accepted keys (all optional): stress, arousal (alias a), sleep_debt,
+    conflict, v, social, trust, closeness, sadness, allostatic_load, energy,
+    loneliness, noise (scalar or per-channel dict), plus labels.emotion as a
+    fallback for sadness/loneliness when those keys are absent.
+    """
+    state = state if isinstance(state, dict) else {}
+    emotion = _emotion(state)
+    arousal = _num(state, "arousal", _num(state, "a", DEFAULTS["arousal"]))
+    sadness = _num(state, "sadness", 0.0)
+    if not sadness and emotion == "sadness":
+        sadness = _clamp(_num(state, "intensity", 0.5), 0.0, 1.0)
+    loneliness = _num(state, "loneliness", 0.0)
+    if not loneliness and emotion == "loneliness":
+        loneliness = _clamp(_num(state, "intensity", 0.5), 0.0, 1.0)
+    return {
+        "stress": _clamp(_num(state, "stress", 0.0)),
+        "arousal": _clamp(arousal),
+        "sleep_debt": _clamp(_num(state, "sleep_debt", 0.0)),
+        "conflict": _clamp(_num(state, "conflict", 0.0)),
+        "v": _clamp(_num(state, "v", 0.0), -1.0, 1.0),
+        "social": _clamp(_num(state, "social", 0.5)),
+        "trust": _clamp(_num(state, "trust", 0.5)),
+        "closeness": _clamp(_num(state, "closeness", 0.5)),
+        "sadness": _clamp(sadness),
+        "allostatic_load": _clamp(_num(state, "allostatic_load", 0.0)),
+        "energy": _clamp(_num(state, "energy", 0.55)),
+        "loneliness": _clamp(loneliness),
+        "noise": _noise_value(state),
+    }
+
+
+def target(state=None):
+    """The four dimension targets from the body state (no smoothing)."""
+    x = inputs(state)
+    tension = (0.45 * x["stress"] + 0.25 * x["arousal"]
+               + 0.20 * x["sleep_debt"] + 0.10 * x["conflict"])
+    warmth = (0.40 * ((x["v"] + 1.0) / 2.0) + 0.25 * x["social"]
+              + 0.20 * x["trust"] + 0.15 * x["closeness"])
+    heaviness = (0.40 * x["sadness"] + 0.30 * x["allostatic_load"]
+                 + 0.20 * (1.0 - x["energy"]) + 0.10 * x["loneliness"])
+    clarity = (0.40 * (1.0 - x["noise"]) + 0.30 * (1.0 - x["sleep_debt"])
+               + 0.30 * (1.0 - abs(x["arousal"] - 0.5) * 2.0))
+    return {"tension": round(_clamp(tension), 4),
+            "warmth": round(_clamp(warmth), 4),
+            "heaviness": round(_clamp(heaviness), 4),
+            "clarity": round(_clamp(clarity), 4)}
+
+
+def _values(intero):
+    intero = intero if isinstance(intero, dict) else {}
+    return {dim: round(_clamp(intero.get(dim, COMFORT[dim])), 4) for dim in DIMS}
+
+
+def _alpha(dt_hours, rate):
+    """Bounded EMA gain for one step: 1 - exp(-rate * dt)."""
+    try:
+        dt = max(0.0, float(dt_hours))
+    except Exception:
+        dt = 0.0
+    try:
+        r = max(0.0, min(1.0, float(rate)))
+    except Exception:
+        r = 0.25
+    if dt <= 0.0 or r <= 0.0:
+        return 0.0
+    return 1.0 - math.exp(-r * dt)
+
+
+def update(prev, state, dt_hours=None, rate=0.25, now=None):
+    """EMA toward target(state); idempotent for the same now.
+
+    dt_hours is the elapsed time since the previous update. When it is None and
+    now plus prev["ts"] are available the delta is derived in hours. A zero
+    delta (or an unchanged now) returns the previous values unchanged.
+    """
+    prev = prev if isinstance(prev, dict) else {}
+    current = _values(prev)
+    stamp = None
+    if now is not None:
+        try:
+            stamp = float(now)
+        except Exception:
+            stamp = None
+    if stamp is not None and prev.get("ts") is not None:
+        try:
+            if abs(float(prev.get("ts")) - stamp) < 1e-9:
+                out = dict(current)
+                out["ts"] = stamp
+                return out
+        except Exception:
+            pass
+    if dt_hours is None and stamp is not None and prev.get("ts") is not None:
+        try:
+            dt_hours = max(0.0, (stamp - float(prev.get("ts"))) / 3600.0)
+        except Exception:
+            dt_hours = 0.0
+    alpha = _alpha(0.0 if dt_hours is None else dt_hours, rate)
+    goal = target(state)
+    out = {}
+    for dim in DIMS:
+        out[dim] = round(_clamp(current[dim] + alpha * (goal[dim] - current[dim])), 4)
+    if stamp is not None:
+        out["ts"] = stamp
+    return out
+
+
+def discomfort(intero, sp=None):
+    """Band-relative weighted deviation: 0 inside every band, > 0 outside.
+
+    sp may override set-points via {"comfort": {...}, "band": {...}} or
+    directly {dim: value} (set-point override). Returns {total, parts} with
+    total normalized to [0, 1] by the worst-case excess.
+    """
+    values = _values(intero)
+    comfort = dict(COMFORT)
+    band = dict(BAND)
+    if isinstance(sp, dict):
+        if isinstance(sp.get("comfort"), dict):
+            comfort.update(sp["comfort"])
+        if isinstance(sp.get("band"), dict):
+            band.update(sp["band"])
+        for dim in DIMS:
+            if dim in sp and not isinstance(sp[dim], dict):
+                comfort[dim] = sp[dim]
+    parts = {}
+    raw = 0.0
+    worst = 0.0
+    for dim in DIMS:
+        center = _clamp(comfort.get(dim, COMFORT[dim]))
+        half = _clamp(band.get(dim, BAND[dim]), 0.0, 1.0)
+        excess = max(0.0, abs(values[dim] - center) - half)
+        parts[dim] = round(excess, 4)
+        weight = float(WEIGHTS[dim])
+        raw += weight * excess
+        worst += weight * max(center - half, (1.0 - center) - half, 0.0)
+    total = 0.0 if worst <= 0.0 else _clamp(raw / worst)
+    return {"total": round(total, 4), "parts": parts}
+
+
+def view(intero):
+    """Public read model: four dims + scalar discomfort."""
+    values = _values(intero)
+    values["discomfort"] = discomfort(values)["total"]
+    return values

package/python/biocore_model/intero_style.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""P1-2 interoception -> expression style (length / tone / initiative).
+
+The four interoceptive channels (tension / warmth / heaviness / clarity, 0..1)
+are felt states, not prompt text. This module is the deterministic bridge that
+turns them into expression knobs the interpretation layer may use:
+
+- length: a reply target/cap multiplier (tense, heavy or unclear -> shorter);
+- tone: one short directive for the dominant felt state (or "" when calm);
+- initiative: 0..1 scalar for how forward the next expression should be.
+
+Pure functions only: no IO, no main import, no prompt text.
+"""
+from __future__ import annotations
+
+CHANNELS = ("tension", "warmth", "heaviness", "clarity")
+DEFAULT_INITIATIVE = 0.5
+MIN_TARGET = 4
+MIN_CAP = 8
+MAX_CAP = 120
+TONE_THRESHOLD = 0.55
+
+TONE_LINES = {
+    "tension": "先接住情绪，句子短一点",
+    "heaviness": "慢一点说，别堆太多话",
+    "warmth": "语气可以亲近一点",
+    "clarity": "没听清就先用一句确认",
+}
+
+
+def _num(value, default=0.0):
+    try:
+        number = float(value)
+    except Exception:
+        return float(default)
+    if number != number:
+        return float(default)
+    return number
+
+
+def _clamp(value, low, high):
+    return max(low, min(high, _num(value, 0.0)))
+
+
+def _has_data(intero):
+    return isinstance(intero, dict) and any(name in intero for name in CHANNELS)
+
+
+def levels(intero):
+    """Clamped 0..1 intero channel dict (unknown channels = 0)."""
+    data = intero if isinstance(intero, dict) else {}
+    return {name: round(_clamp(data.get(name, 0.0), 0.0, 1.0), 4)
+            for name in CHANNELS}
+
+
+def tone(intero):
+    """Dominant felt-state directive, "" when nothing stands out.
+
+    Low clarity is a special case: not hearing the other side well is a
+    directive of its own (ask one clarifying question) even when it is not the
+    numerically highest channel.
+    """
+    if not _has_data(intero):
+        return ""
+    felt = levels(intero)
+    if felt["clarity"] < TONE_THRESHOLD * 0.5:
+        return TONE_LINES["clarity"]
+    ranked = sorted(felt.items(), key=lambda item: item[1], reverse=True)
+    name, value = ranked[0]
+    if value < TONE_THRESHOLD:
+        return ""
+    if name == "clarity":
+        return ""
+    return TONE_LINES.get(name, "")
+
+
+def length_factor(intero):
+    """Multiplier for reply length: warmth lengthens, tension/heaviness shortens."""
+    if not _has_data(intero):
+        return 1.0
+    felt = levels(intero)
+    factor = (1.0
+              - 0.50 * felt["tension"]
+              - 0.40 * felt["heaviness"]
+              + 0.40 * felt["warmth"]
+              + 0.25 * (felt["clarity"] - 0.5))
+    return round(_clamp(factor, 0.4, 1.6), 3)
+
+
+def initiative(intero):
+    """How forward the next expression should be (0..1)."""
+    if not _has_data(intero):
+        return DEFAULT_INITIATIVE
+    felt = levels(intero)
+    value = (DEFAULT_INITIATIVE
+             + 0.45 * felt["warmth"]
+             - 0.35 * felt["heaviness"]
+             - 0.30 * felt["tension"]
+             + 0.10 * felt["clarity"])
+    return round(_clamp(value, 0.0, 1.0), 3)
+
+
+def style(intero, target=10, cap=30):
+    """Reply knobs for one interoceptive state (bounded, deterministic)."""
+    base_target = max(MIN_TARGET, int(_num(target, 10)))
+    base_cap = max(MIN_CAP, int(_num(cap, 30)))
+    factor = length_factor(intero)
+    new_target = max(MIN_TARGET, int(round(base_target * factor)))
+    new_cap = max(new_target, max(MIN_CAP, int(round(base_cap * factor))))
+    new_cap = min(MAX_CAP, new_cap)
+    directive = tone(intero)
+    return {"target": new_target, "cap": new_cap,
+            "tone": directive, "initiative": initiative(intero),
+            "factor": factor,
+            "applied": bool(directive) or abs(factor - 1.0) > 1e-9,
+            "levels": levels(intero)}