dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_memory/recall/embedding.py

@@ -25,6 +25,17 @@ except Exception:  # pragma: no cover - top-level/standalone tests
     from embedding_mode import resolve_mode  # type: ignore
 
 EMBED_CACHE_MAX = 512
+
+# task-221: observable cache/provider counters (process-local, never raises).
+EMBED_STATS = {"hit": 0, "disk_hit": 0, "miss": 0, "remote": 0, "local": 0, "fail": 0}
+
+
+def embed_stats(reset=False):
+    data = dict(EMBED_STATS)
+    if reset:
+        for key in EMBED_STATS:
+            EMBED_STATS[key] = 0
+    return data
 EMBED_TEXT_MAX_CHARS = 2000
 DEFAULT_TIMEOUT, MIN_TIMEOUT, MAX_TIMEOUT = 5.0, 0.1, 60.0
 ENV_BASE_URL = "BIOCORE_EMBEDDING_BASE_URL"
@@ -105,6 +116,104 @@ def _validate_vector(value) -> Optional[List[float]]:
     return out
 
 
+CACHE_FILE_ENV = "BIOCORE_EMBEDDING_CACHE_FILE"
+STATS_FILE_ENV = "BIOCORE_EMBED_STATS_FILE"
+_STATS_FLUSHED = {}
+
+
+def _stats_file():
+    return os.environ.get(STATS_FILE_ENV) or None
+
+
+def _flush_stats():
+    """Persist counters so /stats keeps counting across spawn-per-call.
+
+    Each bridge call is a fresh process; the file accumulates deltas since the
+    last flush of this process (never raises, never blocks a turn).
+    """
+    path = _stats_file()
+    if not path:
+        return
+    try:
+        previous = {}
+        if os.path.isfile(path):
+            try:
+                with open(path, encoding="utf-8") as handle:
+                    loaded = json.load(handle)
+                if isinstance(loaded, dict):
+                    previous = loaded
+            except Exception:
+                previous = {}
+        merged = {}
+        for key in EMBED_STATS:
+            try:
+                before = int(previous.get(key, 0) or 0)
+            except Exception:
+                before = 0
+            merged[key] = before + EMBED_STATS[key] - _STATS_FLUSHED.get(key, 0)
+        directory = os.path.dirname(path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+        tmp = path + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as handle:
+            json.dump(merged, handle)
+        os.replace(tmp, path)
+        _STATS_FLUSHED.update(EMBED_STATS)
+    except Exception:
+        pass
+
+
+def _cache_file():
+    path = os.environ.get(CACHE_FILE_ENV) or ""
+    if not path:
+        return None
+    try:
+        os.makedirs(path, exist_ok=True)
+        return os.path.join(path, "embedding-cache.jsonl")
+    except Exception:
+        return None
+
+
+def _disk_lookup(file_path, key):
+    if not file_path or not os.path.isfile(file_path):
+        return None
+    try:
+        with open(file_path, encoding="utf-8") as fh:
+            for line in fh:
+                try:
+                    row = json.loads(line)
+                except Exception:
+                    continue
+                if row.get("k") == key:
+                    return _validate_vector(row.get("v"))
+    except Exception:
+        return None
+    return None
+
+
+def _disk_put(file_path, key, vector, keep=512):
+    if not file_path:
+        return
+    try:
+        rows = []
+        if os.path.isfile(file_path):
+            with open(file_path, encoding="utf-8") as fh:
+                for line in fh:
+                    try:
+                        rows.append(json.loads(line))
+                    except Exception:
+                        continue
+        rows = [r for r in rows if r.get("k") != key]
+        rows.append({"k": key, "v": list(vector)})
+        rows = rows[-keep:]
+        with open(file_path + ".tmp", "w", encoding="utf-8") as fh:
+            for row in rows:
+                fh.write(json.dumps(row, ensure_ascii=False) + "\n")
+        os.replace(file_path + ".tmp", file_path)
+    except Exception:
+        return
+
+
 def _cache_get(cache, key):
     if cache is None:
         return None
@@ -719,6 +828,13 @@ def _call_provider(provider, text, timeout):
 
 def embed(text, provider, cache=None, timeout=None):
     """Return a vector for text, or None (never raises); LRU cache optional."""
+    try:
+        return _embed_impl(text, provider, cache, timeout)
+    finally:
+        _flush_stats()
+
+
+def _embed_impl(text, provider, cache=None, timeout=None):
     if provider is None:
         return None
     normalized = normalize_text(text)
@@ -727,19 +843,32 @@ def embed(text, provider, cache=None, timeout=None):
     key = cache_key(normalized)
     cached = _cache_get(cache, key)
     if cached is not None:
+        EMBED_STATS["hit"] += 1
         try:  # true LRU when the caller passes an OrderedDict
             cache.move_to_end(key)
         except Exception:
             pass
         return cached
+    disk = _cache_file()
+    from_disk = _disk_lookup(disk, key) if disk else None
+    if from_disk is not None:
+        EMBED_STATS["disk_hit"] += 1
+        _cache_put(cache, key, from_disk)
+        return from_disk
+    EMBED_STATS["miss"] += 1
     checked = _validate_vector(
         _call_provider(provider, normalized, _timeout_for(provider, timeout)))
     if checked is not None:
+        EMBED_STATS["remote"] += 1
         _cache_put(cache, key, checked)
+        _disk_put(disk, key, checked)
         return checked
     # Remote failed / timed out / missing key: try the local CPU int8 model.
     local = _fallback_embed(provider, normalized)
     if local is None:
+        EMBED_STATS["fail"] += 1
         return None
+    EMBED_STATS["local"] += 1
     _cache_put(cache, key, local)
+    _disk_put(disk, key, local)
     return local

package/python/biocore_memory/recall/feedback.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+"""task-218: recall feedback into affect ("回忆回灌情绪").
+
+A recalled memory already carries the affect it was encoded with (task-217,
+entry["affect"]). Recall may feed a small share of that stored affect back
+into the live affect state, so remembering a warm moment lifts the mood a
+little and remembering a bad one pulls it down -- then stops.
+
+Three guards, all from core/config.py:
+
+  CAP       per-turn |delta| <= FEEDBACK_MAX_STEP, valence and arousal apart
+  COOLDOWN  the same entry cannot feed twice inside FEEDBACK_COOLDOWN seconds
+            (the caller owns the {entry_id: last_ts} map)
+  FLOOR     at valence <= FEEDBACK_NEG_FLOOR a further negative pull is
+            dropped to 0 and the caller is told (blocked_negative) to run a
+            regulation strategy instead
+
+Pure: no IO, no clock, no host import, never touches the store. The engine
+passes the rows it actually injected (top-k), the current affect and now,
+so one recall can be replayed exactly in a test.
+"""
+from __future__ import annotations
+
+from ..core.config import (FEEDBACK_COOLDOWN, FEEDBACK_GAIN,
+                           FEEDBACK_MAX_STEP, FEEDBACK_NEG_FLOOR)
+
+
+def _num(value, default=0.0):
+    try:
+        number = float(value)
+    except Exception:
+        return default
+    return number if number == number else default
+
+
+def _clamp(value, low, high):
+    return max(low, min(high, _num(value, low)))
+
+
+def _pair(source):
+    """(valence, arousal) from a dict, a 2-sequence or an object."""
+    if isinstance(source, dict):
+        v = source.get("v", source.get("valence", 0.0))
+        a = source.get("a", source.get("arousal", 0.5))
+    elif isinstance(source, (list, tuple)) and len(source) >= 2:
+        v, a = source[0], source[1]
+    else:
+        v = getattr(source, "v", getattr(source, "valence", 0.0))
+        a = getattr(source, "a", getattr(source, "arousal", 0.5))
+    return _clamp(_num(v, 0.0), -1.0, 1.0), _clamp(_num(a, 0.5), 0.0, 1.0)
+
+
+def _entry_of(row):
+    if isinstance(row, dict):
+        entry = row.get("entry")
+        if isinstance(entry, dict):
+            return entry
+    return row if isinstance(row, dict) else {}
+
+
+def stored_affect(entry):
+    """(valence, arousal) stored at write time, or None when absent."""
+    if not isinstance(entry, dict):
+        return None
+    affect = entry.get("affect")
+    if not isinstance(affect, dict):
+        return None
+    if "valence" not in affect and "v" not in affect:
+        return None
+    raw_v = affect.get("valence", affect.get("v"))
+    raw_a = affect.get("arousal", affect.get("a", 0.5))
+    try:
+        valid_v = float(raw_v)
+        valid_a = float(raw_a)
+    except Exception:
+        return None
+    if valid_v != valid_v or valid_a != valid_a:  # NaN
+        return None
+    return (_clamp(valid_v, -1.0, 1.0), _clamp(valid_a, 0.0, 1.0))
+
+
+def key_of(entry):
+    """Stable cooldown key: the entry id, else a text prefix."""
+    entry = entry if isinstance(entry, dict) else {}
+    entry_id = str(entry.get("id") or "").strip()
+    if entry_id:
+        return entry_id
+    return "text:" + str(entry.get("text") or "")[:40]
+
+
+def _weight(entry):
+    return _clamp(entry.get("importance", 0.5) if isinstance(entry, dict) else 0.5,
+                  0.0, 1.0)
+
+
+def plan(rows, current, cooldowns=None, now=0.0, budget=None,
+         gain=None, max_step=None, cooldown=None, neg_floor=None):
+    """Decide the per-turn affect nudge for one recall batch.
+
+    rows       what this recall injected (row dicts or raw entries); trimmed
+               to budget when given
+    current    live affect: dict {v/a | valence/arousal}, (v, a) or object
+    cooldowns  {entry key: last feedback ts}; read only, the caller updates it
+    """
+    cooldowns = cooldowns if isinstance(cooldowns, dict) else {}
+    now = _num(now, 0.0)
+    gain = _clamp(FEEDBACK_GAIN if gain is None else gain, 0.0, 1.0)
+    max_step = max(0.0, _num(FEEDBACK_MAX_STEP if max_step is None else max_step,
+                             FEEDBACK_MAX_STEP))
+    cool = max(0.0, _num(FEEDBACK_COOLDOWN if cooldown is None else cooldown,
+                         FEEDBACK_COOLDOWN))
+    floor = _clamp(FEEDBACK_NEG_FLOOR if neg_floor is None else neg_floor,
+                   -1.0, 1.0)
+    before_v, before_a = _pair(current)
+
+    batch = [row for row in (rows or []) if isinstance(row, dict)]
+    if budget is not None:
+        try:
+            batch = batch[:max(1, int(budget))]
+        except Exception:
+            pass
+
+    skipped = []
+    eligible = []  # (key, (v, a), weight)
+    for row in batch:
+        entry = _entry_of(row)
+        key = key_of(entry)
+        pair = stored_affect(entry)
+        if pair is None:
+            skipped.append({"id": key, "reason": "no_affect"})
+            continue
+        last = cooldowns.get(key)
+        if last is not None and now - _num(last, 0.0) < cool:
+            skipped.append({"id": key, "reason": "cooldown"})
+            continue
+        eligible.append((key, pair, _weight(entry)))
+
+    report = {
+        "enabled": True,
+        "before": [round(before_v, 4), round(before_a, 4)],
+        "target": None,
+        "delta": [0.0, 0.0],
+        "after": [round(before_v, 4), round(before_a, 4)],
+        "eligible": [key for key, _value, _weight_value in eligible],
+        "applied": [],
+        "skipped": skipped,
+        "capped": False,
+        "blocked_negative": False,
+        "regulation": None,
+        "reason": "",
+    }
+    if not eligible:
+        report["reason"] = "no_eligible_memory"
+        return report
+
+    total_w = sum(weight for _key, _value, weight in eligible)
+    if total_w <= 0:
+        total_w = float(len(eligible))
+        weights = [1.0] * len(eligible)
+    else:
+        weights = [weight for _key, _value, weight in eligible]
+    target_v = sum(pair[0] * weight
+                   for (_key, pair, _weight_value), weight
+                   in zip(eligible, weights)) / total_w
+    target_a = sum(pair[1] * weight
+                   for (_key, pair, _weight_value), weight
+                   in zip(eligible, weights)) / total_w
+    target_v = _clamp(target_v, -1.0, 1.0)
+    target_a = _clamp(target_a, 0.0, 1.0)
+
+    raw_v = (target_v - before_v) * gain
+    raw_a = (target_a - before_a) * gain
+    delta_v = max(-max_step, min(max_step, raw_v))
+    delta_a = max(-max_step, min(max_step, raw_a))
+    report["capped"] = bool(abs(raw_v) > max_step + 1e-12
+                            or abs(raw_a) > max_step + 1e-12)
+
+    if delta_v < 0 and before_v <= floor:
+        # Already low: do not push further down; regulation takes over.
+        delta_v = 0.0
+        report["blocked_negative"] = True
+        report["reason"] = "negative_floor"
+
+    report["target"] = [round(target_v, 4), round(target_a, 4)]
+    report["delta"] = [round(delta_v, 6), round(delta_a, 6)]
+    report["after"] = [round(_clamp(before_v + delta_v, -1.0, 1.0), 4),
+                       round(_clamp(before_a + delta_a, 0.0, 1.0), 4)]
+    if delta_v or delta_a:
+        report["applied"] = list(report["eligible"])
+        report["reason"] = report["reason"] or "ok"
+    else:
+        report["reason"] = report["reason"] or "no_change"
+    return report
+
+
+def enabled(flags=None, env=None):
+    """Flag or env switch; both default off (old behaviour)."""
+    flags = flags if isinstance(flags, dict) else {}
+    if flags.get("memory_feedback") is True:
+        return True
+    raw = env.get("BIOCORE_MEMORY_FEEDBACK") if hasattr(env, "get") else None
+    return str(raw or "").strip().lower() in ("1", "true", "on", "yes")

package/python/biocore_model/preference_drift.py

@@ -0,0 +1,255 @@
+# -*- coding: utf-8 -*-
+"""task-219: repeated topics slowly drift the value_order weights.
+
+Memory already knows what keeps coming back. This module counts those topics
+with the tokenizer that already ships in biocore_model (memory_store.bigrams
+for CJK, a latin-word regex), maps the ones with a known dimension onto
+value_order, and -- only once a topic has appeared in more than
+TOPIC_THRESHOLD memory entries -- nudges that dimension by a small amount per
+new occurrence.
+
+Guards, all here so a theme can never rewrite her in one night:
+
+  THRESHOLD  cumulative occurrences must pass TOPIC_THRESHOLD (5)
+  PER CALL   one step moves a dimension by at most DAILY_CAP (0.01), which is
+             also the per-day allowance; callers run one step per day
+  BOUNDS     every weight stays inside value_order.WEIGHT_FLOOR..CEIL
+  WATERMARK  only occurrences since the previous call drift the table
+             (last_counts), so replaying the same batch is idempotent
+  DECAY      a dimension whose topic stopped being active relaxes toward
+             value_order.DEFAULTS by DECAY_PER_DAY per elapsed day
+  LAYERS     biocore_model only; never writes a memory entry, never touches
+             the persona file, never renders prompt text
+
+Pure functions only: no IO, no clock, no host imports, no LLM calls. The
+caller passes weights, counts and the last watermark, so a drift step can be
+replayed exactly in a test. Default OFF: flags {"preference_drift": True} or
+env BIOCORE_PREFERENCE_DRIFT=1.
+"""
+from __future__ import annotations
+
+import re
+
+try:
+    from . import value_order as _vo
+except Exception:  # pragma: no cover - degraded checkout
+    _vo = None
+
+TOPIC_THRESHOLD = 5
+PER_REPEAT = 0.002
+DAILY_CAP = 0.01
+DECAY_PER_DAY = 0.0005
+MAX_TOPICS = 24
+
+_WS = re.compile(r"\s+")
+_LATIN = re.compile(r"[a-z][a-z0-9_']*")
+_CJK = re.compile(r"[\u4e00-\u9fff]+")
+
+# topic keyword -> value_order dimension; the longest matching keyword wins.
+TOPIC_DIMENSIONS = (
+    ("self_direction", ("自由", "自己做主", "自己决定", "独立", "选择", "决定")),
+    ("stimulation", ("新鲜", "刺激", "旅行", "冒险", "出去玩", "尝试")),
+    ("hedonism", ("开心", "好吃", "吃", "玩", "舒服", "放松")),
+    ("achievement", ("认可", "夸", "厉害", "成功", "进步", "成绩")),
+    ("power", ("掌控", "主导", "说话算数", "权力", "命令")),
+    ("security", ("安全", "害怕", "担心", "不安", "稳定")),
+    ("conformity", ("规矩", "礼貌", "应该", "不能", "越界")),
+    ("tradition", ("传统", "习惯", "以前", "老规矩")),
+    ("benevolence", ("陪", "需要我", "帮你", "关心", "照顾", "倾听")),
+    ("universalism", ("公平", "诚实", "尊重", "正义", "原则")),
+)
+
+STOPWORDS = frozenset((
+    "我们", "你们", "他们", "她们", "这个", "那个", "就是", "不是", "一个",
+    "什么", "怎么", "可以", "没有", "因为", "所以", "然后", "还是", "现在",
+    "今天", "明天", "知道", "觉得", "自己", "已经", "这样", "那样", "东西",
+))
+FALLBACK_DEFAULTS = {
+    "self_direction": 0.62, "stimulation": 0.45, "hedonism": 0.40,
+    "achievement": 0.55, "power": 0.38, "security": 0.70,
+    "conformity": 0.35, "tradition": 0.30, "benevolence": 0.75,
+    "universalism": 0.60,
+}
+
+
+def _num(value, default=0.0):
+    try:
+        number = float(value)
+    except Exception:
+        return default
+    return number if number == number else default
+
+
+def _clamp(value, low, high):
+    return max(low, min(high, _num(value, low)))
+
+
+def _dimensions():
+    return tuple(_vo.DIMENSIONS) if _vo is not None else tuple(FALLBACK_DEFAULTS)
+
+
+def _defaults():
+    return dict(_vo.DEFAULTS) if _vo is not None else dict(FALLBACK_DEFAULTS)
+
+
+def enabled(flags=None, env=None):
+    """Flag or env switch; both default OFF (old behaviour)."""
+    flags = flags if isinstance(flags, dict) else {}
+    if flags.get("preference_drift") is True:
+        return True
+    raw = env.get("BIOCORE_PREFERENCE_DRIFT") if hasattr(env, "get") else None
+    return str(raw or "").strip().lower() in ("1", "true", "on", "yes")
+
+
+def topics(text, limit=MAX_TOPICS):
+    """Topic tokens for one memory text (CJK bigrams + latin words)."""
+    lowered = _WS.sub(" ", str(text or "").lower())
+    out = []
+    seen = set()
+    for run in _CJK.findall(lowered):
+        if len(run) < 2:
+            continue
+        for index in range(len(run) - 1):
+            cand = run[index:index + 2]
+            if cand in seen or cand in STOPWORDS:
+                continue
+            seen.add(cand)
+            out.append(cand)
+            if len(out) >= limit:
+                return out
+    for word in _LATIN.findall(lowered):
+        if len(word) < 3 or word in seen or word in STOPWORDS:
+            continue
+        seen.add(word)
+        out.append(word)
+        if len(out) >= limit:
+            break
+    return out
+
+
+def dimension_of(topic):
+    """value_order dimension for a topic, or None (longest keyword wins)."""
+    key = str(topic or "").lower()
+    if not key:
+        return None
+    best = None
+    best_len = 0
+    for dim, keywords in TOPIC_DIMENSIONS:
+        for word in keywords:
+            if word in key and len(word) > best_len:
+                best, best_len = dim, len(word)
+    return best
+
+
+def accumulate(counts=None, entries=None):
+    """Add one count per entry per topic; returns a new dict (never mutates)."""
+    table = {}
+    if isinstance(counts, dict):
+        for key, value in counts.items():
+            table[str(key)] = int(_num(value, 0))
+    for entry in entries or []:
+        text = entry.get("text") if isinstance(entry, dict) else str(entry or "")
+        if not text:
+            continue
+        for topic in set(topics(text)):
+            table[topic] = table.get(topic, 0) + 1
+    return table
+
+
+def count_topics(entries):
+    """Cumulative topic counts for a whole memory list."""
+    return accumulate({}, entries)
+
+
+def decay_counts(counts=None, days=0.0, half_life_days=60.0):
+    """Halve the counts once per half-life; keeps a fading theme fading."""
+    days = max(0.0, _num(days, 0.0))
+    half_life = max(1e-6, _num(half_life_days, 60.0))
+    factor = 0.5 ** (days / half_life)
+    table = {}
+    if isinstance(counts, dict):
+        for key, value in counts.items():
+            table[str(key)] = round(max(0.0, _num(value, 0.0)) * factor, 4)
+    return table
+
+
+def step(weights=None, counts=None, last_counts=None, days=1.0,
+         enabled=True, threshold=TOPIC_THRESHOLD, per_repeat=PER_REPEAT,
+         daily_cap=DAILY_CAP, decay_per_day=DECAY_PER_DAY):
+    """One drift step. Call once per day with the counts seen so far.
+
+    weights      the current value table (normalized copy is returned)
+    counts       cumulative topic occurrences in memory
+    last_counts  the counts watermark from the previous step
+    days         elapsed days since the previous step (decay only)
+    """
+    if _vo is None:
+        return {"enabled": bool(enabled), "weights": dict(weights or {}),
+                "drifted": {}, "decayed": [], "active": {}, "counts": {},
+                "reason": "value_order_unavailable"}
+    base = _vo.normalize(weights)
+    result = {"enabled": bool(enabled), "weights": base, "drifted": {},
+              "decayed": [], "active": {}, "counts": {}, "reason": "ok"}
+    if not enabled:
+        result["reason"] = "disabled"
+        return result
+
+    counts = counts if isinstance(counts, dict) else {}
+    last = last_counts if isinstance(last_counts, dict) else {}
+    days = max(0.0, _num(days, 1.0))
+    threshold = max(1, int(_num(threshold, TOPIC_THRESHOLD)))
+    per_repeat = _clamp(per_repeat, 0.0, DAILY_CAP)
+    cap = _clamp(daily_cap, 0.0, 0.05)
+    decay = _clamp(decay_per_day, 0.0, DAILY_CAP)
+    dimensions = _dimensions()
+    defaults = _defaults()
+
+    fresh = {}
+    active = {}
+    for topic, total in counts.items():
+        total = _num(total, 0.0)
+        if total <= threshold:
+            continue
+        active[str(topic)] = total
+        new = max(0.0, total - _num(last.get(topic), 0.0))
+        if new:
+            fresh[str(topic)] = new
+    result["active"] = active
+
+    by_dim = {}
+    for topic, new in fresh.items():
+        dim = dimension_of(topic)
+        if dim is None:
+            continue
+        by_dim[dim] = by_dim.get(dim, 0.0) + per_repeat * new
+    active_dims = {dimension_of(topic) for topic in active}
+    for dim, raw in by_dim.items():
+        delta = min(cap, raw)
+        if delta <= 0:
+            continue
+        before = base[dim]
+        base[dim] = round(_clamp(before + delta, _vo.WEIGHT_FLOOR,
+                                 _vo.WEIGHT_CEIL), 4)
+        moved = round(base[dim] - before, 4)
+        if moved:
+            result["drifted"][dim] = moved
+
+    if decay > 0 and days > 0:
+        relax = min(cap * days, decay * days)
+        for dim in dimensions:
+            if dim in active_dims or dim in result["drifted"]:
+                continue
+            before = base[dim]
+            default = _num(defaults.get(dim), before)
+            if abs(before - default) <= 1e-9:
+                continue
+            toward = 1.0 if default > before else -1.0
+            base[dim] = round(_clamp(before + toward * min(relax, abs(default - before)),
+                                     _vo.WEIGHT_FLOOR, _vo.WEIGHT_CEIL), 4)
+            if abs(base[dim] - before) > 1e-9:
+                result["decayed"].append(dim)
+
+    result["weights"] = base
+    result["counts"] = {str(key): _num(value, 0.0)
+                        for key, value in counts.items()}
+    return result

package/python/biocore_model/tests/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

package/python/biocore_model/tests/core_mode_ui_check.mjs

@@ -0,0 +1,63 @@
+import assert from 'node:assert'
+import { CORE_MODES, coreModeButtons, describeBridgeError, coreModeConfirmText, coreModeSuccessText, coreBridgeLabel, createCoreModeFlow } from '../core_mode_ui.mjs'
+assert.deepEqual(CORE_MODES, ['off', 'shadow', 'primary'])
+assert.deepEqual(coreModeButtons('off'), { shadow: { disabled: false }, primary: { disabled: false }, rollback: { disabled: true } })
+assert.deepEqual(coreModeButtons('shadow'), { shadow: { disabled: true }, primary: { disabled: false }, rollback: { disabled: false } })
+assert.deepEqual(coreModeButtons('primary'), { shadow: { disabled: false }, primary: { disabled: true }, rollback: { disabled: false } })
+assert.equal(coreModeButtons('bogus').rollback.disabled, false)  // unknown mode -> all switches enabled
+assert.equal(coreModeButtons(undefined).shadow.disabled, false)
+assert.equal(coreModeButtons('primary').rollback.disabled, false)
+assert.equal(describeBridgeError({ status: 403, message: 'forbidden' }), 'HTTP 403：forbidden')
+assert.equal(describeBridgeError({ statusCode: 400, code: 'invalid_params', message: 'invalid mode' }), 'HTTP 400 invalid_params：invalid mode')
+assert.equal(describeBridgeError(new Error('boom')), 'boom')
+assert.equal(describeBridgeError({ payload: { code: 'integrity_refused', message: 'refused' } }), 'integrity_refused：refused')
+assert.equal(coreModeConfirmText('shadow'), '确认切到影子模式？')
+assert.equal(coreModeConfirmText('off'), '确认回退到旧版引擎？')
+assert.ok(coreModeConfirmText('primary').includes('核心为主'))
+assert.equal(coreModeSuccessText('shadow'), '已切到影子模式')
+assert.equal(coreModeSuccessText('off'), '已回退旧版引擎')
+assert.equal(coreModeSuccessText('primary', true), '已切到核心模式（重启后生效）')
+assert.equal(coreBridgeLabel(true), '桥接：已连接')
+assert.equal(coreBridgeLabel(false), '桥接：未连接（静态预览）')
+// DOM stub: inline confirm flow (no window.confirm anywhere)
+function makeView({ bridge = true, post = async () => ({ ok: true, mode: 'shadow' }) } = {}) {
+  const state = { confirm: null, toast: null, error: null, posts: 0 }
+  return {
+    state,
+    setConfirm(value) { state.confirm = value },
+    setToast(value) { state.toast = value },
+    setError(value) { state.error = value },
+    bridgeAvailable() { return bridge },
+    buttons() { return { shadow: { disabled: false }, primary: { disabled: false }, off: { disabled: true } } },
+    post(mode) { state.posts += 1; return post(mode) }
+  }
+}
+const view = makeView()
+const flow = createCoreModeFlow({ post: (mode) => view.post(mode), view })
+const clicked = flow.click('shadow')
+assert.equal(clicked.showConfirm, true)
+assert.equal(view.state.confirm, '确认切到影子模式？')
+assert.equal(flow.click('off').disabled, true)  // off button disabled -> no confirm
+flow.cancel()
+assert.equal(view.state.confirm, null)
+assert.equal(flow.calls, 0)
+flow.click('shadow')
+const okRun = await flow.confirm()
+assert.equal(okRun.called, true)
+assert.equal(flow.calls, 1)
+assert.equal(view.state.posts, 1)
+assert.equal(view.state.toast, '已切到影子模式')
+const errView = makeView({ post: async () => { const e = new Error('forbidden'); e.status = 403; throw e } })
+const errFlow = createCoreModeFlow({ post: (mode) => errView.post(mode), view: errView })
+errFlow.click('primary')
+await errFlow.confirm()
+assert.ok(errView.state.toast.includes('HTTP 403'), errView.state.toast)
+assert.ok(errView.state.error.includes('403'))
+const offView = makeView({ bridge: false })
+const offFlow = createCoreModeFlow({ post: (mode) => offView.post(mode), view: offView })
+offFlow.click('shadow')
+const offRun = await offFlow.confirm()
+assert.equal(offRun.called, false)
+assert.ok(offView.state.toast.includes('未连接'), offView.state.toast)
+assert.equal(offView.state.posts, 0)
+console.log('CORE MODE UI OK (23 checks)')