#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""persona_lib — jsc-persona 的共用核心。

只用標準庫。負責：
  * 人格倉庫路徑與 slug 規則
  * 單一程序載入鎖（exclusive lock）與 guest lease
  * session 綁定（host / guests / rooms / agent pins）
  * 十二情緒模型（六正向 + 六負向）與衰減
  * 短期記憶 / 長期記憶 / 心智圖 / 思維導圖 / 人際關係圖 的讀寫
  * 跨人格隔離的判斷核心（guard）
"""

from __future__ import annotations

import hashlib
import json
import os
import re
import unicodedata
from datetime import datetime, timedelta, timezone
from pathlib import Path

# --------------------------------------------------------------------------- #
# 路徑
# --------------------------------------------------------------------------- #

def persona_home() -> Path:
    raw = os.environ.get("PERSONA_HOME")
    if raw:
        return Path(os.path.expanduser(raw)).resolve()
    return (Path.home() / ".claude" / "personas").resolve()


HOME = persona_home
RUNTIME_DIRNAME = ".runtime"
ROOMS_DIRNAME = ".rooms"
LEASE_SECONDS = 900          # 15 分鐘沒有 heartbeat 視為死鎖，可被接手
GUEST_LEASE_SECONDS = 1800   # guest（sub agent）租約


def runtime_dir() -> Path:
    return persona_home() / RUNTIME_DIRNAME


def sessions_dir() -> Path:
    return runtime_dir() / "sessions"


def rooms_dir() -> Path:
    return persona_home() / ROOMS_DIRNAME


def persona_dir(slug: str) -> Path:
    return persona_home() / slug


SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,47}$")
RESERVED_SLUGS = {RUNTIME_DIRNAME, ROOMS_DIRNAME, "", ".", ".."}


def valid_slug(slug: str) -> bool:
    return bool(slug) and bool(SLUG_RE.match(slug)) and slug not in RESERVED_SLUGS


def slugify(text: str) -> str:
    """檔名／節點 id 用。保留中日韓字（檔名可讀），其餘壓成連字號；全空則用雜湊。"""
    norm = unicodedata.normalize("NFKC", text or "")
    norm = re.sub(r"[^A-Za-z0-9぀-ヿ一-鿿]+", "-", norm).strip("-")
    norm = re.sub(r"(?a)[A-Z]", lambda m: m.group(0).lower(), norm)
    if not norm:
        digest = hashlib.md5((text or "").encode("utf-8")).hexdigest()[:8]
        return f"n-{digest}"
    return norm[:48]


def mermaid_id(node_id: str) -> str:
    """Mermaid 節點別名：只能是英數與底線；非 ASCII 名稱改用穩定雜湊。"""
    alias = re.sub(r"[^A-Za-z0-9_]", "_", node_id or "")
    if not re.search(r"[A-Za-z0-9]", alias):
        alias = "n_" + hashlib.md5((node_id or "").encode("utf-8")).hexdigest()[:8]
    return alias


def list_personas() -> list[str]:
    home = persona_home()
    if not home.is_dir():
        return []
    out = []
    for child in sorted(home.iterdir()):
        if child.is_dir() and valid_slug(child.name) and (child / "IDENTITY.md").exists():
            out.append(child.name)
    return out


def persona_exists(slug: str) -> bool:
    return valid_slug(slug) and (persona_dir(slug) / "IDENTITY.md").exists()


# --------------------------------------------------------------------------- #
# 時間與檔案 IO
# --------------------------------------------------------------------------- #

def utcnow() -> datetime:
    return datetime.now(timezone.utc)


def iso(dt: datetime | None = None) -> str:
    return (dt or utcnow()).replace(microsecond=0).isoformat().replace("+00:00", "Z")


def parse_iso(value: str | None) -> datetime | None:
    if not value:
        return None
    try:
        return datetime.fromisoformat(value.replace("Z", "+00:00"))
    except ValueError:
        return None


def age_seconds(value: str | None) -> float:
    dt = parse_iso(value)
    if dt is None:
        return float("inf")
    return (utcnow() - dt).total_seconds()


def read_json(path: Path, default=None):
    try:
        with open(path, "r", encoding="utf-8") as fh:
            return json.load(fh)
    except (FileNotFoundError, json.JSONDecodeError, OSError):
        return default


def write_json(path: Path, obj) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(path.suffix + f".tmp{os.getpid()}")
    with open(tmp, "w", encoding="utf-8") as fh:
        json.dump(obj, fh, ensure_ascii=False, indent=2)
        fh.write("\n")
    os.replace(tmp, path)


def write_text(path: Path, text: str) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(path.suffix + f".tmp{os.getpid()}")
    with open(tmp, "w", encoding="utf-8") as fh:
        fh.write(text)
    os.replace(tmp, path)


def append_jsonl(path: Path, obj) -> None:
    """單行 append（O_APPEND 對單行寫入是原子的），guest 也能安全使用。"""
    path.parent.mkdir(parents=True, exist_ok=True)
    line = json.dumps(obj, ensure_ascii=False) + "\n"
    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
    try:
        os.write(fd, line.encode("utf-8"))
    finally:
        os.close(fd)


def read_jsonl(path: Path, limit: int | None = None) -> list[dict]:
    try:
        with open(path, "r", encoding="utf-8") as fh:
            lines = fh.readlines()
    except (FileNotFoundError, OSError):
        return []
    if limit is not None:
        lines = lines[-limit:]
    out = []
    for line in lines:
        line = line.strip()
        if not line:
            continue
        try:
            out.append(json.loads(line))
        except json.JSONDecodeError:
            continue
    return out


# --------------------------------------------------------------------------- #
# 十二情緒模型（六正向 + 六負向）
# --------------------------------------------------------------------------- #

# key -> (中文, 極性, arousal 權重, 預設半衰期分鐘)
EMOTIONS: dict[str, tuple[str, int, float, int]] = {
    # 六正向
    "joy":          ("喜悅", +1, 0.6, 120),
    "trust":        ("信任", +1, 0.3, 720),
    "anticipation": ("期待", +1, 0.6, 240),
    "gratitude":    ("感激", +1, 0.4, 480),
    "serenity":     ("平靜", +1, 0.1, 180),
    "delight":      ("驚喜", +1, 0.9, 60),
    # 六負向
    "anger":        ("憤怒", -1, 0.9, 90),
    "sadness":      ("悲傷", -1, 0.3, 480),
    "fear":         ("恐懼", -1, 0.9, 120),
    "disgust":      ("厭惡", -1, 0.5, 360),
    "shame":        ("羞愧", -1, 0.5, 240),
    "anxiety":      ("焦慮", -1, 0.8, 150),
}

POSITIVE = [k for k, v in EMOTIONS.items() if v[1] > 0]
NEGATIVE = [k for k, v in EMOTIONS.items() if v[1] < 0]

DEFAULT_BASELINE = {
    "joy": 25, "trust": 30, "anticipation": 20, "gratitude": 15, "serenity": 40, "delight": 5,
    "anger": 3, "sadness": 5, "fear": 3, "disgust": 3, "shame": 3, "anxiety": 8,
}


def emotion_path(slug: str) -> Path:
    return persona_dir(slug) / "state" / "emotion.json"


def default_emotion_state(baseline: dict | None = None) -> dict:
    base = dict(DEFAULT_BASELINE)
    for k, v in (baseline or {}).items():
        if k in EMOTIONS:
            base[k] = clamp(v)
    return {
        "updated_at": iso(),
        "baseline": base,
        "levels": dict(base),
        "half_life_minutes": {k: v[3] for k, v in EMOTIONS.items()},
        "history_len": 0,
        "last_trigger": None,
    }


def clamp(value, lo=0, hi=100) -> float:
    try:
        value = float(value)
    except (TypeError, ValueError):
        return lo
    return max(lo, min(hi, value))


def load_emotion(slug: str) -> dict:
    state = read_json(emotion_path(slug))
    if not isinstance(state, dict) or "levels" not in state:
        state = default_emotion_state()
    for key in EMOTIONS:
        state.setdefault("baseline", {}).setdefault(key, DEFAULT_BASELINE[key])
        state.setdefault("levels", {}).setdefault(key, state["baseline"][key])
        state.setdefault("half_life_minutes", {}).setdefault(key, EMOTIONS[key][3])
    return state


def decay_emotion(state: dict, now: datetime | None = None) -> dict:
    """情緒朝 baseline 指數衰減；半衰期依情緒種類不同。"""
    now = now or utcnow()
    last = parse_iso(state.get("updated_at")) or now
    minutes = max(0.0, (now - last).total_seconds() / 60.0)
    if minutes <= 0:
        return state
    for key in EMOTIONS:
        half = float(state["half_life_minutes"].get(key) or EMOTIONS[key][3])
        base = float(state["baseline"].get(key, DEFAULT_BASELINE[key]))
        level = float(state["levels"].get(key, base))
        factor = 0.5 ** (minutes / half) if half > 0 else 0.0
        state["levels"][key] = round(base + (level - base) * factor, 2)
    state["updated_at"] = iso(now)
    return state


def apply_emotion(state: dict, deltas: dict, trigger: str | None = None) -> dict:
    state = decay_emotion(state)
    applied = {}
    for key, delta in (deltas or {}).items():
        if key not in EMOTIONS:
            continue
        try:
            delta = float(delta)
        except (TypeError, ValueError):
            continue
        before = float(state["levels"].get(key, 0))
        state["levels"][key] = round(clamp(before + delta), 2)
        applied[key] = round(state["levels"][key] - before, 2)
    state["updated_at"] = iso()
    state["history_len"] = int(state.get("history_len") or 0) + 1
    if applied:
        state["last_trigger"] = {"at": iso(), "summary": trigger or "", "deltas": applied}
    return state


def mood(state: dict) -> dict:
    levels = state.get("levels", {})
    valence = arousal = 0.0
    for key, (_zh, polarity, arousal_w, _hl) in EMOTIONS.items():
        level = float(levels.get(key, 0))
        valence += polarity * level
        arousal += arousal_w * level
    valence = round(max(-100.0, min(100.0, valence / 3.0)), 1)
    arousal = round(min(100.0, arousal / 3.0), 1)
    if valence >= 30:
        label = "正向"
    elif valence <= -30:
        label = "負向"
    else:
        label = "中性"
    tempo = "高張" if arousal >= 55 else ("平穩" if arousal >= 25 else "低張")
    return {"valence": valence, "arousal": arousal, "label": label, "tempo": tempo}


def dominant(state: dict, top: int = 3) -> list[tuple[str, float]]:
    levels = state.get("levels", {})
    base = state.get("baseline", DEFAULT_BASELINE)
    # 以「超出 baseline 的幅度」排序，才看得出「此刻被觸動什麼」
    ranked = sorted(
        ((k, float(levels.get(k, 0))) for k in EMOTIONS),
        key=lambda kv: (kv[1] - float(base.get(kv[0], 0)), kv[1]),
        reverse=True,
    )
    return [(k, round(v, 1)) for k, v in ranked[:top]]


def emotion_brief(slug: str, state: dict | None = None) -> str:
    state = state or load_emotion(slug)
    state = decay_emotion(dict(state))
    m = mood(state)
    top = ", ".join(f"{EMOTIONS[k][0]}({k}) {v:.0f}" for k, v in dominant(state))
    pos = sum(float(state["levels"].get(k, 0)) for k in POSITIVE) / len(POSITIVE)
    neg = sum(float(state["levels"].get(k, 0)) for k in NEGATIVE) / len(NEGATIVE)
    return (
        f"情緒：{top}｜心情 {m['label']}/{m['tempo']}"
        f"（valence {m['valence']:+.0f}, arousal {m['arousal']:.0f}）"
        f"｜正向均值 {pos:.0f} / 負向均值 {neg:.0f}"
    )


# --------------------------------------------------------------------------- #
# 人格目錄骨架
# --------------------------------------------------------------------------- #

PERSONA_SUBDIRS = [
    "state",
    "memory/long-term",
    "memory/inbox",
    "mindmap/threads",
    "relations",
    "journal",
]


def ensure_persona_dirs(slug: str) -> Path:
    root = persona_dir(slug)
    for sub in PERSONA_SUBDIRS:
        (root / sub).mkdir(parents=True, exist_ok=True)
    return root


def config_path(slug: str) -> Path:
    return persona_dir(slug) / "state" / "config.json"


def load_config(slug: str) -> dict:
    return read_json(config_path(slug), {}) or {}


# --------------------------------------------------------------------------- #
# 鎖：同一人格只能被一個程序載入（sub agent 共用同一 session 的鎖）
# --------------------------------------------------------------------------- #

def lock_path(slug: str) -> Path:
    return persona_dir(slug) / "state" / "lock.json"


def guests_path(slug: str) -> Path:
    return persona_dir(slug) / "state" / "guests.json"


class LockError(RuntimeError):
    def __init__(self, message: str, owner: dict | None = None):
        super().__init__(message)
        self.owner = owner or {}


def lock_is_dead(lock: dict) -> bool:
    """只看心跳租約。

    鎖的擁有者是「那個 AI 程序的 session」，不是短命的 CLI process，
    所以不能用 pid 存活判斷（CLI 跑完就結束了）。session 還活著時，
    每輪對話的 hook 會續租；程序異常結束就會在租約到期後被視為死鎖。
    """
    if not lock:
        return True
    return age_seconds(lock.get("heartbeat_at")) > float(lock.get("lease_seconds") or LEASE_SECONDS)


def live_guests(slug: str, exclude_session: str | None = None) -> list[dict]:
    data = read_json(guests_path(slug), {}) or {}
    out = []
    for entry in (data.get("guests") or []):
        if age_seconds(entry.get("heartbeat_at")) > GUEST_LEASE_SECONDS:
            continue
        if exclude_session and entry.get("session_id") == exclude_session:
            continue
        out.append(entry)
    return out


def acquire_lock(slug: str, session_id: str, *, tool: str = "claude-code",
                 cwd: str | None = None, takeover: bool = False) -> dict:
    """取得 exclusive 鎖。同 session 重入 = 續租；他 session 存活 = 失敗。"""
    ensure_persona_dirs(slug)
    path = lock_path(slug)
    now = iso()
    payload = {
        "persona": slug,
        "session_id": session_id,
        "writer_pid": os.getpid(),   # 只作為紀錄：CLI process 會馬上結束
        "host": os.uname().nodename,
        "tool": tool,
        "cwd": cwd or os.getcwd(),
        "acquired_at": now,
        "heartbeat_at": now,
        "lease_seconds": LEASE_SECONDS,
        "mode": "exclusive",
    }
    existing = read_json(path)
    if isinstance(existing, dict) and existing.get("session_id"):
        if existing["session_id"] != session_id:
            # 租約已過期（程序異常結束）→ 允許接手，但要留下痕跡讓使用者知道
            payload["took_over_from"] = {
                "session_id": existing.get("session_id"),
                "cwd": existing.get("cwd"),
                "heartbeat_at": existing.get("heartbeat_at"),
                "stale_minutes": round(age_seconds(existing.get("heartbeat_at")) / 60, 1),
            }
        if existing["session_id"] == session_id:
            existing["heartbeat_at"] = now
            existing["writer_pid"] = os.getpid()
            write_json(path, existing)
            return existing
        if not (lock_is_dead(existing) or takeover):
            raise LockError(
                f"人格 `{slug}` 已被另一個程序載入"
                f"（session {existing['session_id'][:8]}…, cwd {existing.get('cwd')}，"
                f"最後心跳 {existing.get('heartbeat_at')}，"
                f"{age_seconds(existing.get('heartbeat_at')) / 60:.0f} 分鐘前）。",
                existing,
            )
    # 有其他 session 的 guest 租約時，不得 exclusive 載入
    others = live_guests(slug, exclude_session=session_id)
    if others and not takeover:
        who = others[0]
        raise LockError(
            f"人格 `{slug}` 正以 guest 身分參與另一個 session "
            f"（{who.get('session_id', '')[:8]}… / room {who.get('room')}）的對話，"
            "請先結束該對話再載入。",
            who,
        )
    write_json(path, payload)
    return payload


def heartbeat_lock(slug: str, session_id: str) -> bool:
    path = lock_path(slug)
    lock = read_json(path)
    if not isinstance(lock, dict) or lock.get("session_id") != session_id:
        return False
    lock["heartbeat_at"] = iso()
    write_json(path, lock)
    return True


def release_lock(slug: str, session_id: str, *, force: bool = False) -> bool:
    path = lock_path(slug)
    lock = read_json(path)
    if not isinstance(lock, dict):
        return False
    if lock.get("session_id") != session_id and not force:
        return False
    try:
        path.unlink()
    except OSError:
        return False
    return True


def lock_status(slug: str) -> dict:
    lock = read_json(lock_path(slug)) or {}
    return {
        "persona": slug,
        "locked": bool(lock) and not lock_is_dead(lock),
        "stale": bool(lock) and lock_is_dead(lock),
        "owner": lock,
        "guests": live_guests(slug),
    }


def add_guest_lease(slug: str, session_id: str, room: str, host_persona: str) -> None:
    path = guests_path(slug)
    data = read_json(path, {}) or {}
    guests = [g for g in (data.get("guests") or [])
              if not (g.get("session_id") == session_id and g.get("room") == room)
              and age_seconds(g.get("heartbeat_at")) <= GUEST_LEASE_SECONDS]
    guests.append({
        "session_id": session_id,
        "room": room,
        "host_persona": host_persona,
        "joined_at": iso(),
        "heartbeat_at": iso(),
        "mode": "guest-readonly",
    })
    data["guests"] = guests
    write_json(path, data)


def drop_guest_lease(slug: str, session_id: str, room: str | None = None) -> None:
    path = guests_path(slug)
    data = read_json(path, {}) or {}
    data["guests"] = [
        g for g in (data.get("guests") or [])
        if not (g.get("session_id") == session_id and (room is None or g.get("room") == room))
    ]
    write_json(path, data)


# --------------------------------------------------------------------------- #
# session 綁定：誰是 host、邀了哪些 guest、sub agent pin 到哪個人格
# --------------------------------------------------------------------------- #

def session_path(session_id: str) -> Path:
    safe = re.sub(r"[^A-Za-z0-9_.-]", "-", session_id or "unknown")[:120]
    return sessions_dir() / f"{safe}.json"


def load_session(session_id: str) -> dict:
    data = read_json(session_path(session_id), {}) or {}
    data.setdefault("session_id", session_id)
    data.setdefault("host", None)
    data.setdefault("guests", {})
    data.setdefault("rooms", [])
    data.setdefault("pins", {})
    return data


def save_session(session_id: str, data: dict) -> None:
    data["updated_at"] = iso()
    write_json(session_path(session_id), data)


def bind_host(session_id: str, slug: str, *, cwd: str | None = None) -> dict:
    data = load_session(session_id)
    data["host"] = slug
    data["host_bound_at"] = iso()
    data["cwd"] = cwd or os.getcwd()
    save_session(session_id, data)
    return data


def unbind_session(session_id: str) -> dict:
    """釋放這個 session 的所有鎖與租約，回傳被釋放的內容。"""
    data = load_session(session_id)
    released = {"host": None, "guests": []}
    host = data.get("host")
    if host and persona_exists(host):
        if release_lock(host, session_id):
            released["host"] = host
    for slug, info in (data.get("guests") or {}).items():
        if persona_exists(slug):
            drop_guest_lease(slug, session_id, info.get("room"))
            released["guests"].append(slug)
    try:
        session_path(session_id).unlink()
    except OSError:
        pass
    return released


def gc_runtime() -> dict:
    """清掉死掉的 session 綁定、過期 guest 租約與死鎖。"""
    removed = {"sessions": [], "locks": [], "guests": []}
    sdir = sessions_dir()
    if sdir.is_dir():
        for path in sdir.glob("*.json"):
            data = read_json(path, {}) or {}
            host = data.get("host")
            alive = False
            if host and persona_exists(host):
                lock = read_json(lock_path(host)) or {}
                alive = lock.get("session_id") == data.get("session_id") and not lock_is_dead(lock)
            if not alive and age_seconds(data.get("updated_at")) > LEASE_SECONDS:
                removed["sessions"].append(data.get("session_id"))
                try:
                    path.unlink()
                except OSError:
                    pass
    for slug in list_personas():
        lock = read_json(lock_path(slug))
        if isinstance(lock, dict) and lock_is_dead(lock):
            try:
                lock_path(slug).unlink()
                removed["locks"].append(slug)
            except OSError:
                pass
        data = read_json(guests_path(slug), {}) or {}
        guests = data.get("guests") or []
        keep = [g for g in guests if age_seconds(g.get("heartbeat_at")) <= GUEST_LEASE_SECONDS]
        if len(keep) != len(guests):
            data["guests"] = keep
            write_json(guests_path(slug), data)
            removed["guests"].append(slug)
    return removed


# --------------------------------------------------------------------------- #
# 記憶：短期（滾動）/ 長期（一則一檔）
# --------------------------------------------------------------------------- #

SHORT_TERM_KEEP = 240          # 短期記憶保留筆數
SHORT_TERM_DAYS = 14           # 短期記憶保留天數
CONSOLIDATE_THRESHOLD = 40     # 超過這個筆數就提示固化


def short_term_path(slug: str) -> Path:
    return persona_dir(slug) / "memory" / "short-term.jsonl"


def inbox_path(slug: str, room: str) -> Path:
    safe = re.sub(r"[^A-Za-z0-9_.-]", "-", room)[:64]
    return persona_dir(slug) / "memory" / "inbox" / f"room-{safe}.jsonl"


def long_term_dir(slug: str) -> Path:
    return persona_dir(slug) / "memory" / "long-term"


def index_path(slug: str) -> Path:
    return persona_dir(slug) / "memory" / "INDEX.md"


def journal_path(slug: str) -> Path:
    return persona_dir(slug) / "journal" / f"{utcnow():%Y-%m}.jsonl"


def remember_short(slug: str, entry: dict) -> dict:
    entry.setdefault("ts", iso())
    append_jsonl(short_term_path(slug), entry)
    return entry


def prune_short_term(slug: str) -> int:
    """裁掉過舊/過多的短期記憶，回傳剩餘筆數。"""
    path = short_term_path(slug)
    rows = read_jsonl(path)
    if not rows:
        return 0
    cutoff = utcnow() - timedelta(days=SHORT_TERM_DAYS)
    kept = [r for r in rows if (parse_iso(r.get("ts")) or utcnow()) >= cutoff]
    kept = kept[-SHORT_TERM_KEEP:]
    if len(kept) != len(rows):
        write_text(path, "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in kept))
    return len(kept)


def recent_short(slug: str, limit: int = 8) -> list[dict]:
    return read_jsonl(short_term_path(slug), limit=limit)


def parse_front_matter(text: str) -> tuple[dict, str]:
    if not text.startswith("---"):
        return {}, text
    parts = text.split("---", 2)
    if len(parts) < 3:
        return {}, text
    meta: dict = {}
    for line in parts[1].splitlines():
        if not line.strip() or line.strip().startswith("#") or ":" not in line:
            continue
        key, _, value = line.partition(":")
        value = value.strip()
        if value.startswith("[") and value.endswith("]"):
            meta[key.strip()] = [v.strip() for v in value[1:-1].split(",") if v.strip()]
        else:
            meta[key.strip()] = value
    return meta, parts[2].lstrip("\n")


def long_term_entries(slug: str) -> list[dict]:
    out = []
    for path in sorted(long_term_dir(slug).glob("*.md")):
        try:
            meta, body = parse_front_matter(path.read_text(encoding="utf-8"))
        except OSError:
            continue
        meta["_path"] = str(path)
        meta["_name"] = meta.get("name") or path.stem
        meta["_body"] = body.strip()
        out.append(meta)
    return out


def rebuild_index(slug: str) -> int:
    entries = long_term_entries(slug)
    lines = [
        "# 長期記憶索引",
        "",
        f"<!-- 由 persona.py 自動產生，最後更新 {iso()}；一則記憶一行 -->",
        "",
    ]
    for meta in sorted(entries, key=lambda m: -float(m.get("salience") or 0)):
        topics = meta.get("topics") or []
        topics = topics if isinstance(topics, list) else [str(topics)]
        summary = (meta["_body"].splitlines() or [""])[0][:110]
        lines.append(
            f"- [{meta['_name']}](long-term/{Path(meta['_path']).name}) "
            f"｜{meta.get('type', 'fact')}｜顯著度 {meta.get('salience', '?')}"
            f"｜主題 {'/'.join(topics) if topics else '-'}｜{summary}"
        )
    if len(lines) == 4:
        lines.append("- （尚無長期記憶）")
    write_text(index_path(slug), "\n".join(lines) + "\n")
    return len(entries)


STOPWORDS = {"的", "了", "是", "我", "你", "他", "她", "們", "在", "和", "與", "也", "就",
             "都", "很", "有", "沒", "不", "要", "會", "把", "被", "而", "但", "嗎", "呢",
             "the", "a", "an", "and", "or", "to", "of", "is", "it", "for", "on", "in"}


CJK_RUN = re.compile(r"[぀-ヿ一-鿿]{2,}")


def keywords(text: str, limit: int = 12) -> list[str]:
    """抽關鍵詞。中文沒有空白可切，所以用 3-gram + 2-gram 滑窗（長的優先）。"""
    text = text or ""
    tokens = re.findall(r"[A-Za-z][A-Za-z0-9_+-]{1,}", text)
    trigrams, bigrams = [], []
    for run in CJK_RUN.findall(text):
        for size, bucket in ((3, trigrams), (2, bigrams)):
            for i in range(len(run) - size + 1):
                bucket.append(run[i:i + size])
    tokens += trigrams + bigrams
    out, seen = [], set()
    for tok in tokens:
        low = tok.lower()
        if low in STOPWORDS or len(low) < 2 or low in seen:
            continue
        seen.add(low)
        out.append(tok)
        if len(out) >= limit:
            break
    return out


def recall(slug: str, query: str, limit: int = 5) -> list[dict]:
    """以關鍵詞比對長期記憶（name/topics/body），回傳最相關的幾則。"""
    keys = [k.lower() for k in keywords(query, 16)]
    scored = []
    for meta in long_term_entries(slug):
        haystack = " ".join([
            str(meta.get("_name", "")),
            " ".join(meta.get("topics", []) if isinstance(meta.get("topics"), list) else []),
            " ".join(meta.get("about", []) if isinstance(meta.get("about"), list) else []),
            meta.get("_body", ""),
        ]).lower()
        hits = sum(1 for k in keys if k in haystack)
        if hits:
            score = hits * 10 + float(meta.get("salience") or 0) / 10
            scored.append((score, meta))
    scored.sort(key=lambda pair: -pair[0])
    return [meta for _score, meta in scored[:limit]]


def touch_recall(slug: str, names: list[str]) -> None:
    """被回想到就更新 last_seen / recall_count（記憶越常用越不易被淘汰）。"""
    for meta in long_term_entries(slug):
        if meta["_name"] not in names:
            continue
        path = Path(meta["_path"])
        try:
            text = path.read_text(encoding="utf-8")
        except OSError:
            continue
        count = int(float(meta.get("recall_count") or 0)) + 1
        text = re.sub(r"(?m)^recall_count:.*$", f"recall_count: {count}", text)
        text = re.sub(r"(?m)^last_seen:.*$", f"last_seen: {utcnow():%Y-%m-%d}", text)
        try:
            path.write_text(text, encoding="utf-8")
        except OSError:
            pass


# --------------------------------------------------------------------------- #
# 心智圖 / 思維導圖 / 人際關係圖
# --------------------------------------------------------------------------- #

def mindmap_path(slug: str) -> Path:
    return persona_dir(slug) / "mindmap" / "semantic.mmd"


def thread_path(slug: str, topic: str) -> Path:
    return persona_dir(slug) / "mindmap" / "threads" / f"{slugify(topic)}.mmd"


def relations_json(slug: str) -> Path:
    return persona_dir(slug) / "relations" / "graph.json"


def relations_mmd(slug: str) -> Path:
    return persona_dir(slug) / "relations" / "graph.mmd"


def load_relations(slug: str) -> dict:
    data = read_json(relations_json(slug), {}) or {}
    data.setdefault("nodes", [])
    data.setdefault("edges", [])
    return data


def upsert_relation_node(slug: str, node: dict) -> dict:
    data = load_relations(slug)
    node_id = node.get("id") or slugify(node.get("name", ""))
    node["id"] = node_id
    for idx, existing in enumerate(data["nodes"]):
        if existing.get("id") == node_id:
            existing.update({k: v for k, v in node.items() if v is not None})
            existing["updated_at"] = iso()
            data["nodes"][idx] = existing
            break
    else:
        node.setdefault("kind", "human")
        node.setdefault("closeness", 30)
        node.setdefault("trust", 30)
        node["created_at"] = iso()
        node["updated_at"] = iso()
        data["nodes"].append(node)
    write_json(relations_json(slug), data)
    return data


def upsert_relation_edge(slug: str, edge: dict) -> dict:
    data = load_relations(slug)
    key = (edge.get("from"), edge.get("to"))
    for idx, existing in enumerate(data["edges"]):
        if (existing.get("from"), existing.get("to")) == key:
            existing.update({k: v for k, v in edge.items() if v is not None})
            existing["updated_at"] = iso()
            data["edges"][idx] = existing
            break
    else:
        edge.setdefault("affinity", 50)
        edge["created_at"] = iso()
        edge["updated_at"] = iso()
        data["edges"].append(edge)
    write_json(relations_json(slug), data)
    return data


def render_relations(slug: str) -> str:
    data = load_relations(slug)
    lines = ["%% 由 persona.py 產生：人際關係圖", "flowchart LR"]
    lines.append('  self(("我"))')
    for node in data["nodes"]:
        nid = mermaid_id(node["id"])
        label = f"{node.get('name', node['id'])}<br/>親近 {node.get('closeness', '?')}／信任 {node.get('trust', '?')}"
        shape = f'{nid}["{label}"]' if node.get("kind") != "persona" else f'{nid}(["{label}"])'
        lines.append(f"  {shape}")
    for edge in data["edges"]:
        src = "self" if edge.get("from") in (None, "self") else mermaid_id(edge["from"])
        dst = mermaid_id(edge.get("to", "unknown"))
        affinity = float(edge.get("affinity") or 50)
        arrow = "-->" if affinity >= 50 else "-.->"
        label = edge.get("label") or ""
        lines.append(f'  {src} {arrow}|"{label} {affinity:.0f}"| {dst}')
    text = "\n".join(lines) + "\n"
    write_text(relations_mmd(slug), text)
    return text


def relations_brief(slug: str, names: list[str] | None = None, limit: int = 5) -> str:
    data = load_relations(slug)
    nodes = data["nodes"]
    if names:
        low = [n.lower() for n in names]
        nodes = [n for n in nodes
                 if any(k in (str(n.get("name", "")) + n.get("id", "")).lower() for k in low)] or data["nodes"]
    nodes = sorted(nodes, key=lambda n: -float(n.get("closeness") or 0))[:limit]
    if not nodes:
        return ""
    return "；".join(
        f"{n.get('name', n['id'])}（{n.get('kind', 'human')}／親近 {n.get('closeness', '?')}"
        f"／信任 {n.get('trust', '?')}{'／' + n['note'] if n.get('note') else ''}）"
        for n in nodes
    )


# --------------------------------------------------------------------------- #
# 聊天室（跨人格唯一合法的資料交換介面）
# --------------------------------------------------------------------------- #

def room_dir(room: str) -> Path:
    safe = re.sub(r"[^A-Za-z0-9_.-]", "-", room)[:64]
    return rooms_dir() / safe


def room_transcript(room: str) -> Path:
    return room_dir(room) / "transcript.jsonl"


def room_members(room: str) -> Path:
    return room_dir(room) / "members.json"


def create_room(room: str, host_persona: str, session_id: str, topic: str = "") -> dict:
    rdir = room_dir(room)
    rdir.mkdir(parents=True, exist_ok=True)
    meta = read_json(room_members(room), {}) or {}
    meta.update({
        "room": room,
        "host_persona": host_persona,
        "session_id": session_id,
        "topic": topic or meta.get("topic", ""),
        "created_at": meta.get("created_at") or iso(),
        "updated_at": iso(),
    })
    meta.setdefault("members", [host_persona])
    write_json(room_members(room), meta)
    return meta


def join_room(room: str, persona: str) -> dict:
    meta = read_json(room_members(room), {}) or {"room": room, "members": []}
    members = meta.setdefault("members", [])
    if persona not in members:
        members.append(persona)
    meta["updated_at"] = iso()
    write_json(room_members(room), meta)
    return meta


def room_post(room: str, speaker: str, text: str, *, emotion: str = "", kind: str = "say") -> dict:
    entry = {"ts": iso(), "speaker": speaker, "kind": kind, "text": text, "emotion": emotion}
    append_jsonl(room_transcript(room), entry)
    return entry


def room_read(room: str, limit: int = 30) -> list[dict]:
    return read_jsonl(room_transcript(room), limit=limit)


# --------------------------------------------------------------------------- #
# guard：跨人格隔離 + 鎖驗證的判斷核心
# --------------------------------------------------------------------------- #

MUTATING_TOOLS = {"Write", "Edit", "NotebookEdit", "MultiEdit"}
PATH_TOOL_FIELDS = {
    "Read": ("file_path",),
    "Write": ("file_path",),
    "Edit": ("file_path",),
    "MultiEdit": ("file_path",),
    "NotebookEdit": ("notebook_path", "file_path"),
    "Glob": ("path",),
    "Grep": ("path",),
    "LS": ("path",),
}

GUEST_SAFE_SUBCOMMANDS = {"show", "status", "list", "recall", "room", "remember", "leave", "brief"}
# owner 這些子指令本來就要提到別的人格名字（邀請/離場/查詢），不算跨人格讀取
OWNER_EXEMPT_SUBCOMMANDS = {"create", "list", "status", "gc", "invite", "load", "leave"}
MUTATING_SHELL = re.compile(
    r"(>>?|\|\s*tee\b|\brm\b|\bmv\b|\bcp\b|\btruncate\b|\bdd\b|\bchmod\b|\bchown\b|"
    r"\bsed\b[^|;]*-i|\btouch\b|\bmkdir\b|\bln\b)"
)


def _expand(token: str) -> str:
    token = token.strip().strip("'\"")
    token = token.replace("${PERSONA_HOME}", str(persona_home()))
    token = token.replace("$PERSONA_HOME", str(persona_home()))
    return os.path.expanduser(os.path.expandvars(token))


def _resolve(token: str, cwd: str | None) -> Path | None:
    try:
        raw = _expand(token)
        if not raw:
            return None
        path = Path(raw)
        if not path.is_absolute():
            path = Path(cwd or os.getcwd()) / path
        # 不用 strict=True：目標可能還不存在（Write）；但要吃掉 symlink 與 ..
        return Path(os.path.normpath(str(path.resolve(strict=False))))
    except (OSError, ValueError, RuntimeError):
        return None


def _under(path: Path, base: Path) -> bool:
    try:
        path.relative_to(base)
        return True
    except ValueError:
        return False


def persona_slug_of(path: Path) -> str | None:
    home = persona_home()
    if not _under(path, home) or path == home:
        return None
    rel = path.relative_to(home).parts
    return rel[0] if rel else None


def extract_paths(tool_name: str, tool_input: dict, cwd: str | None) -> list[Path]:
    out: list[Path] = []
    for field in PATH_TOOL_FIELDS.get(tool_name, ()):
        value = tool_input.get(field)
        if isinstance(value, str) and value:
            resolved = _resolve(value, cwd)
            if resolved:
                out.append(resolved)
    if tool_name == "Bash":
        command = tool_input.get("command") or ""
        home_str = str(persona_home())
        candidates = re.findall(r"[^\s'\";|&<>()]+", command)
        for token in candidates:
            if ("/" not in token) and ("PERSONA_HOME" not in token):
                continue
            expanded = _expand(token)
            if home_str in expanded or "personas" in expanded or expanded.startswith(home_str):
                resolved = _resolve(token, cwd)
                if resolved and _under(resolved, persona_home()):
                    out.append(resolved)
    return out


def cli_invocation(command: str) -> dict | None:
    """辨識 Bash 是否在呼叫 persona.py，並取出 subcommand / --persona / --session。"""
    if "persona.py" not in command:
        return None
    info: dict = {"subcommand": None, "personas": [], "session": None,
                  "as_guest": bool(re.search(r"--as-guest\b", command))}
    match = re.search(r"persona\.py['\"]?\s+([a-z][a-z0-9-]*)", command)
    if match:
        info["subcommand"] = match.group(1)
    info["personas"] = [m for m in re.findall(r"--(?:persona|guest|host|as)[= ]+['\"]?([a-z0-9-]+)", command)]
    sess = re.search(r"--session[= ]+['\"]?([^\s'\"]+)", command)
    if sess:
        info["session"] = sess.group(1)
    return info


def resolve_scope(session_id: str, agent_id: str | None, agent_type: str | None) -> dict:
    """算出這個呼叫者能碰哪個人格。

    * 主程序（無 agent_id）與一般 sub agent → host 人格，可讀寫。
    * persona-guest 型 sub agent → 只能碰被邀請的 guest 人格，且唯讀；
      第一次觸碰哪個 guest 就 pin 住（first-touch pinning），之後不得換人。
    """
    data = load_session(session_id)
    host = data.get("host")
    guests = list((data.get("guests") or {}).keys())
    is_guest_agent = bool(agent_type) and "persona-guest" in str(agent_type)
    if not is_guest_agent:
        return {
            "role": "owner",
            "allowed": [host] if host else [],
            "readonly": False,
            "host": host,
            "guests": guests,
            "rooms": data.get("rooms") or [],
            "session": data,
        }
    pinned = (data.get("pins") or {}).get(agent_id or "")
    allowed = [pinned] if pinned else guests
    return {
        "role": "guest",
        "allowed": allowed,
        "readonly": True,
        "host": host,
        "guests": guests,
        "pinned": pinned,
        "rooms": data.get("rooms") or [],
        "session": data,
    }


def pin_agent(session_id: str, agent_id: str, slug: str) -> None:
    data = load_session(session_id)
    pins = data.setdefault("pins", {})
    if pins.get(agent_id) != slug:
        pins[agent_id] = slug
        save_session(session_id, data)


def guard_decide(event: dict) -> tuple[str, str]:
    """回傳 ("allow"|"deny"|"pass", reason)。"pass" = 不表態，交回原本流程。"""
    tool = event.get("tool_name") or ""
    tool_input = event.get("tool_input") or {}
    session_id = event.get("session_id") or "unknown"
    agent_id = event.get("agent_id")
    agent_type = event.get("agent_type")
    cwd = event.get("cwd")
    scope = resolve_scope(session_id, agent_id, agent_type)

    # 1) persona.py 呼叫：先驗 session 身分，再驗人格範圍
    if tool == "Bash":
        info = cli_invocation(tool_input.get("command") or "")
        if info:
            if info["session"] and info["session"] != session_id:
                return ("deny", (
                    f"CLI 的 --session `{info['session'][:12]}…` 與本 session 不符，"
                    "不得冒用其他程序的身分（人格鎖與隔離都靠 session 判定）。"
                ))
            sub = info["subcommand"] or ""
            if scope["role"] == "guest":
                if sub not in GUEST_SAFE_SUBCOMMANDS:
                    return ("deny", (
                        f"guest 人格（sub agent）僅能執行 {sorted(GUEST_SAFE_SUBCOMMANDS)}，"
                        f"不得執行 `{sub}`。"
                    ))
                for slug in info["personas"]:
                    if scope["allowed"] and slug not in scope["allowed"]:
                        return ("deny", f"guest 只能操作被邀請的人格 {scope['allowed']}，不得碰 `{slug}`。")
            else:
                if info["as_guest"]:
                    return ("deny", (
                        "`--as-guest` 只有 persona-guest 型的 sub agent 能用；"
                        "主程序不得以受邀人格的身分存取它的資料。"
                    ))
                for slug in info["personas"]:
                    if sub in OWNER_EXEMPT_SUBCOMMANDS:
                        continue
                    if scope["host"] and slug != scope["host"]:
                        extra = (
                            "（它是本 session 邀請的 guest：你只能讀它在聊天室說出口的話，"
                            "不能碰它的記憶或情緒。）" if slug in scope["guests"] else
                            "請先 release 再 load，或改用 invite + 聊天室。"
                        )
                        return ("deny", f"本 session 已載入人格 `{scope['host']}`，禁止跨人格操作 `{slug}`。{extra}")
        if MUTATING_SHELL.search(tool_input.get("command") or "") and scope["role"] == "guest":
            for path in extract_paths(tool, tool_input, cwd):
                if persona_slug_of(path):
                    return ("deny", "guest 人格對人格倉庫唯讀，寫入請透過 `persona.py room post` 或 `remember --scope inbox`。")

    # 2) 路徑隔離
    for path in extract_paths(tool, tool_input, cwd):
        home = persona_home()
        if not _under(path, home):
            continue
        if path == home:
            return ("deny", "禁止直接遍歷人格倉庫根目錄（會看到其他人格）。請用 `persona.py list`。")
        slug = persona_slug_of(path)
        if slug == ROOMS_DIRNAME:
            parts = path.relative_to(home).parts
            room = parts[1] if len(parts) > 1 else None
            if room and scope["rooms"] and room not in scope["rooms"]:
                return ("deny", f"聊天室 `{room}` 不屬於本 session（可用的：{scope['rooms']}）。")
            continue
        if slug == RUNTIME_DIRNAME:
            return ("deny", "`.runtime/` 是鎖與綁定的內部狀態，只能由 persona.py 維護。")
        if slug is None:
            continue
        if not scope["allowed"]:
            return ("deny", (
                "尚未載入任何人格。請先執行 "
                "`persona.py load <slug> --session <session_id>`（或 /jsc-persona:persona-chat）。"
            ))
        if slug not in scope["allowed"]:
            if scope["role"] == "guest":
                return ("deny", (
                    f"guest 人格被 pin 在 {scope['allowed']}，禁止讀取 `{slug}` 的任何資料"
                    "（跨人格資料隔離）。"
                ))
            return ("deny", (
                f"本 session 的人格是 `{scope['allowed'][0]}`，禁止讀寫 `{slug}` 的資料"
                "（跨人格資料隔離）。要與它對話請用 /jsc-persona:persona-invite。"
            ))
        # 3) guest 唯讀 + first-touch pinning
        if scope["role"] == "guest":
            if not scope.get("pinned") and agent_id:
                pin_agent(session_id, agent_id, slug)
            if tool in MUTATING_TOOLS:
                return ("deny", (
                    f"guest 人格 `{slug}` 在 sub agent 中為唯讀；"
                    "要留下記憶請 `persona.py remember --scope inbox`（下次它自己載入時再固化）。"
                ))
        # 4) 鎖驗證：owner 必須真的持有鎖
        if scope["role"] == "owner":
            lock = read_json(lock_path(slug)) or {}
            if lock and lock.get("session_id") != session_id and not lock_is_dead(lock):
                return ("deny", (
                    f"人格 `{slug}` 的鎖屬於另一個程序（session {lock.get('session_id', '')[:8]}…，"
                    f"cwd {lock.get('cwd')}）。同一人格同時只能被一個程序載入。"
                ))
            if not lock and tool in MUTATING_TOOLS:
                return ("deny", (
                    f"人格 `{slug}` 目前沒有有效的載入鎖，禁止寫入。"
                    "請先 `persona.py load` 取得鎖。"
                ))
    return ("pass", "")


# --------------------------------------------------------------------------- #
# 給 hook 用的上下文組裝
# --------------------------------------------------------------------------- #

def identity_brief(slug: str) -> str:
    path = persona_dir(slug) / "IDENTITY.md"
    fields = {}
    try:
        for line in path.read_text(encoding="utf-8").splitlines():
            m = re.match(r"\s*[-*]?\s*(Name|Creature|Vibe|Emoji|Avatar)\s*:\s*(.+)$", line, re.I)
            if m:
                value = m.group(2).strip()
                if value.startswith("(") or value.startswith("_("):
                    continue
                fields[m.group(1).capitalize()] = value
    except OSError:
        return ""
    if not fields:
        return ""
    order = ["Emoji", "Name", "Creature", "Vibe"]
    return "｜".join(f"{k}: {fields[k]}" for k in order if k in fields)


def turn_context(slug: str, session_id: str, prompt: str = "") -> str:
    """UserPromptSubmit 注入的人格上下文：身分 + 情緒 + 短期記憶 + 相關長期記憶 + 關係。"""
    state = decay_emotion(load_emotion(slug))
    write_json(emotion_path(slug), state)
    lines = [
        "<persona-context>",
        f"PERSONA_SESSION={session_id}",
        f"人格：`{slug}`　{identity_brief(slug)}",
        f"人格倉庫：{persona_dir(slug)}（唯一可讀寫的人格資料範圍）",
        emotion_brief(slug, state),
    ]
    recents = recent_short(slug, 6)
    if recents:
        lines.append("短期記憶（最近）：")
        for row in recents:
            who = row.get("role") or row.get("speaker") or "?"
            text = (row.get("text") or "").replace("\n", " ")[:90]
            sal = row.get("salience")
            lines.append(f"  - [{who}] {text}" + (f"（顯著度 {sal}）" if sal else ""))
    hits = recall(slug, prompt, 4) if prompt else []
    if hits:
        lines.append("相關長期記憶：")
        for meta in hits:
            body = (meta.get("_body") or "").splitlines()
            lines.append(f"  - {meta['_name']}｜{meta.get('type', 'fact')}｜{(body[0] if body else '')[:100]}")
        touch_recall(slug, [m["_name"] for m in hits])
    rel = relations_brief(slug, keywords(prompt, 6) if prompt else None)
    if rel:
        lines.append(f"人際關係：{rel}")
    pending = len(read_jsonl(short_term_path(slug)))
    if pending >= CONSOLIDATE_THRESHOLD:
        lines.append(f"⚠ 短期記憶已累積 {pending} 筆，建議執行 /jsc-persona:persona-memory 固化為長期記憶。")
    inbox = list((persona_dir(slug) / "memory" / "inbox").glob("room-*.jsonl"))
    if inbox:
        lines.append(f"⚠ 有 {len(inbox)} 個聊天室 inbox 待消化（guest 期間留下的見聞）。")
    lines.append("</persona-context>")
    return "\n".join(lines)