virtual-life 1.0.0__py3-none-any.whl

adult.py

@@ -0,0 +1,287 @@
+"""囡囡成人实时模式：18 岁后按真实时钟逐日过活。
+
+用法：
+    python adult.py                # 跑今天剩余时段
+    python adult.py --loop         # 常驻：每 10 分钟检查，到点自动跑对应槽位
+    python adult.py --date 2026-11-07
+
+记忆库：life_seed42.db（延续 18 年的记忆与遗忘曲线状态）
+人格：18 岁成人礼的 L3 画像 + birth.render() 家庭环境
+日记：data/diary_life/adult/YYYY-MM-DD.md（四段式+钟点）
+"""
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+import time
+from datetime import date, datetime, timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import config
+
+Path("logs").mkdir(parents=True, exist_ok=True)
+
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s %(levelname)s %(message)s",
+                    handlers=[logging.StreamHandler(),
+                              logging.FileHandler("logs/adult.log", encoding="utf-8")])
+log = logging.getLogger("adult")
+
+SLOTS = ("morning", "afternoon", "evening", "night")
+ADULT_DIARY = config.DATA_DIR / "diary_life" / "adult"
+
+
+def build_ctx(seed: int = 42):
+    """组装成人模式的 ctx：复用 runner 的 Protocol 契约。"""
+    from types import SimpleNamespace
+    from scheduler import runner
+    from life import LifeSim
+    from world import director as director_mod
+    from world.physics import build_skeleton, validate_events, derive_outcome, apply_outcome, due_foreshadows
+    from contracts import ProtagonistState, NpcState, Foreshadow, Event
+
+    sim = LifeSim(seed)
+    sim.store()               # 先初始化 store（_store 为 None 时 _embed_ok 会炸）
+    sim._store._embed_ok = True
+    persona_card = sim.birth.render()
+    # L3 画像常驻人格：从库里取 persona 层
+    persona_traits = [n["text"] for n in sim.store().recent(days=99999)
+                      if n.get("kind") == "persona" or "persona" in str(n)]
+    persona_text = persona_card + "\n\n她的性格（由经历沉淀）：\n" + "\n".join(
+        f"- {t}" for t in persona_traits[:7])
+
+    state = ProtagonistState(energy=75, mood=15, money=2800, location="家")
+    npc_map = {
+        "妈妈": NpcState(name="妈妈", relationship=60, facts=["教师", "每周日来电话"]),
+        "爸爸": NpcState(name="爸爸", relationship=35, facts=["长途司机", "惊蛰带种子"]),
+        "外婆": NpcState(name="外婆", relationship=65, facts=["同住", "种瓜藤", "腰痛过"]),
+    }
+
+    from world.world_sim import WorldSim
+    from world.needs import Needs, init_from_birth, EVENT_EFFECTS
+    world_sim = WorldSim(seed=seed)
+    needs = init_from_birth(sim.birth.temperament)
+
+    class AdultDirector:
+        def __init__(self):
+            self.llm = director_mod.LLMClient(model=config._think_model(),
+                                              base_url=config.LLM_BASE_URL or _cfg_local("llm_base_url"),
+                                              timeout=480.0)
+            from world import physics
+            self.physics = physics
+
+        def make_day_plan(self, d: date, context: dict):
+            reality = context.get("reality") or {}
+            skeleton = build_skeleton(d)
+            # 成人日 prompt：L3 画像+家庭+最近记忆
+            recent = sim.store().recent(days=30.0)
+            chronicle = "\n".join(f"[{n['when']:%m-%d}] {n['text']}" for n in recent[-30:]) or "（新篇章）"
+            from world.timetable import format_timetable
+            hooks = ""
+            w = reality.get("weather")
+            if w:
+                hooks += f"真实天气：{w.get('desc')} {w.get('temp_c')}°C。"
+            headlines = reality.get("headlines") or []
+            if headlines:
+                hooks += "新闻：" + "；".join(headlines[:2])
+            sys_extra = (f"主角囡囡，18 岁，刚高中毕业待业/准备大学。性格：\n"
+                         + "\n".join(f"- {t}" for t in persona_traits[:7])
+                         + f"\n家庭：{persona_card}\n地点只用：家、公司、小区、便利店、超市、公园、医院、地铁站。")
+            # P1 世界自转：世界今日事件（导演可见暗线，用于埋迹象）
+            world_events = world_sim.tick(d)
+            from world.world_sim import world_block
+            hooks += "\n【世界今日】\n" + world_block(world_events, include_hidden=True)
+            # P2 需求阈值：状态逼出的事件
+            hooks += "\n" + needs.block()
+            # 上帝之手：用户干预必须消化（读后清空）
+            import json as _jh
+            gh = Path(__file__).resolve().parent / "data" / "godhand" / "pending.json"
+            if gh.exists():
+                try:
+                    items = _jh.loads(gh.read_text(encoding="utf-8"))
+                    if items:
+                        hooks += "\n【上帝之手的干预，今天的计划必须把这些事编进去】"
+                        hooks += "\n" + "\n".join(f"- {it['text']}" for it in items)
+                        gh.unlink()
+                except Exception:
+                    pass
+            from world.director import PlanContext, Director
+            ctx = PlanContext(
+                chronicle=chronicle,
+                free_slots=list(SLOTS), fixed_slots=[],
+                money=state.money, mood=state.mood, energy=state.energy,
+                location=state.location,
+                reality_hooks=hooks + sys_extra)
+            director = Director(llm=self.llm)
+            plan = director.plan_day(
+                d, skeleton, state, chronicle, [], list(npc_map.values()),
+                [], reality_hooks=hooks)
+            return plan
+
+    class AdultProtagonist:
+        def __init__(self):
+            from llm import LLMClient
+            self.client = LLMClient()
+
+        def react(self, events, memory_hits, persona_text, slot_hint: str = "morning"):
+            from protagonist import react
+            return react(self.client, persona_text, events, memory_hits,
+                         sim_date=date.today(), slot_hint=slot_hint)
+
+    class AdultMemory:
+        def __init__(self):
+            self.store = sim.store()
+
+        def retrieve(self, query: str, k: int = 5):
+            nodes = self.store.retrieve(query, top_k=k)
+            from contracts import MemoryHit
+            return [MemoryHit(when=n["when"], text=n["text"], kind=n["kind"],
+                              importance=n["importance"]) for n, _ in nodes]
+
+        def reflect(self, entries) -> str:
+            from llm import LLMClient
+            c = LLMClient()
+            thoughts = self.store.reflect(c.chat)
+            return "；".join(t["text"] for t in thoughts) or "（今天没什么特别的）"
+
+        def add_event(self, kind, text, when=None, importance=3.0):
+            return self.store.add(kind, text, when=when, importance=importance)
+
+    class Paths:
+        db = sim.db_path
+        diary_dir = ADULT_DIARY
+        checkpoint_file = config.DATA_DIR / "checkpoints" / "adult_state.json"
+        backup_dir = config.DATA_DIR / "backups"
+        inbox_dir = config.DATA_DIR / "inbox"
+
+    class AdultReality:
+        def get_weather(self, city): 
+            from reality.weather import get_weather
+            return get_weather(city)
+        def get_headlines(self, n=5):
+            from reality.news import get_headlines
+            return get_headlines(n)
+        def scan_inbox(self, dir_path=None):
+            from reality.inbox import scan_inbox
+            return scan_inbox(dir_path)
+
+    ctx = SimpleNamespace(
+        paths=Paths(), reality=AdultReality(),
+        memory=AdultMemory(), director=AdultDirector(),
+        protagonist=AdultProtagonist(),
+        persona_text=persona_text,
+        state_holder=SimpleNamespace(state=state, npc_map=npc_map),
+    )
+    return ctx, runner
+
+
+def _llm_chat():
+    from llm import LLMClient
+    return LLMClient().chat
+
+
+def _cfg_local(key: str):
+    """config_local.json 读取（start.py 引导产物）。"""
+    try:
+        import json as _j, os as _o
+        lp = _o.path.join(_o.path.dirname(_o.path.abspath(__file__)), 'config_local.json')
+        if _o.path.exists(lp):
+            return _j.load(open(lp, encoding='utf-8')).get(key)
+    except Exception:
+        pass
+    return None
+
+
+def tick() -> None:
+    """按时刻表跑今天该跑的槽位（checkpoint 防重跑）。"""
+    import json
+    from scheduler import runner as runner_mod
+    from world.timetable import current_slot
+
+    ctx, runner_mod2 = build_ctx()
+    cp_file = ctx.paths.checkpoint_file
+    done_slots = set()
+    if cp_file.exists():
+        try:
+            data = json.loads(cp_file.read_text(encoding="utf-8"))
+            if data.get("date") == date.today().isoformat():
+                done_slots = set(data.get("done_slots", []))
+        except (OSError, ValueError):
+            pass
+    now = datetime.now()
+    # 凌晨 0-6 点：睡梦时段，跑一个梦而不是日常槽位
+    if now.hour < 6:
+        from memory.dream import dream_night
+        dream = dream_night(ctx.client.chat if hasattr(ctx, 'client') else _llm_chat(), ctx.memory.store, now)
+        if dream:
+            log.info("adult: 凌晨梦完成（%d 字）", len(dream))
+        else:
+            log.info("adult: 凌晨梦失败/跳过")
+        return
+    label, cur_slot = current_slot(now, now.replace(hour=0, minute=0, second=0, microsecond=0))
+    # 已过当前槽的全部待跑槽位（凌晨属昨夜 night，跳过）
+    todo = [s for s in SLOTS if s not in done_slots and
+            SLOTS.index(s) <= SLOTS.index(cur_slot)]
+    if not todo:
+        log.info("adult: %s 无待跑槽位（已跑 %s）", date.today(), sorted(done_slots))
+        return
+    # 一天只调一次导演：当天无 DayPlan 存档则现生成
+    plan_file = config.DATA_DIR / "checkpoints" / f"adult_plan_{date.today().isoformat()}.json"
+    from contracts import DayPlan
+    if plan_file.exists():
+        day_plan = DayPlan.model_validate_json(plan_file.read_text(encoding="utf-8"))
+        log.info("adult: 复用当日计划（%d 事件）", len(day_plan.events))
+    else:
+        reality = {"weather": ctx.reality.get_weather(config.CITY),
+                   "headlines": ctx.reality.get_headlines(3), "inbox": []}
+        try:
+            day_plan = ctx.director.make_day_plan(date.today(), {"reality": reality})
+        except RuntimeError as exc:
+            log.warning("adult: 导演失败（%s），今晚到此为止，明早 tick 重试", str(exc)[:80])
+            return
+        plan_file.parent.mkdir(parents=True, exist_ok=True)
+        plan_file.write_text(day_plan.model_dump_json(), encoding="utf-8")
+        log.info("adult: 生成当日计划（%d 事件）", len(day_plan.events))
+    for slot in todo:
+        seg = [e for e in day_plan.events if e.slot == slot]
+        runner_mod2.run_slot(date.today(), slot, seg, ctx, reality, None)
+        done_slots.add(slot)
+        cp_file.parent.mkdir(parents=True, exist_ok=True)
+        cp_file.write_text(json.dumps({
+            "date": date.today().isoformat(), "done_slots": sorted(done_slots),
+            "saved_at": datetime.now().isoformat(timespec="seconds"),
+        }, ensure_ascii=False, indent=1), encoding="utf-8")
+        log.info("adult: %s 完成（日记 %s）", slot, "有" if seg else "空段占位")
+    # 夜槽跑完 → 夜间反思 + 备份
+    if "night" in done_slots and len(done_slots) == 4:
+        entries = []
+        try:
+            from scheduler.runner import _load_entries_from_md, _night_reflection
+            _night_reflection(ctx, date.today())
+            log.info("adult: 夜间反思完成")
+        except Exception as exc:
+            log.warning("adult: 夜间反思失败 %s", exc)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--loop", action="store_true", help="常驻模式")
+    ap.add_argument("--interval", type=int, default=600)
+    args = ap.parse_args()
+    if args.loop:
+        log.info("=== 囡囡成人模式常驻启动 ===")
+        while True:
+            try:
+                tick()
+            except Exception as exc:
+                log.error("tick 异常: %s", exc)
+            time.sleep(args.interval)
+    else:
+        tick()
+
+
+if __name__ == "__main__":
+    main()

burn_night.py

@@ -0,0 +1,52 @@
+"""夜间控烧训练：烧 GLM(11451) 直到剩余 <100M 自动停。
+
+用户要求：明早 09:00 前剩余 <1 亿。当前剩余 ~266M → 今夜烧 ~167M。
+主力任务：monthly_redistill（历史重蒸馏，纯 GLM 消耗，产出 L1/L2 有价值）。
+每轮 ~15-25M，跑 ~8-10 轮达标即停。
+"""
+import sys, time, json
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import urllib.request
+
+
+def glm_remaining() -> float | None:
+    try:
+        with urllib.request.urlopen("http://127.0.0.1:11451/v1/balance", timeout=10) as r:
+            d = json.load(r)
+        return d["buckets"][0]["remaining"]
+    except Exception:
+        return None
+
+
+def main() -> None:
+    target = 100e6   # 剩余低于 1 亿即停
+    rounds = 0
+    log = []
+    print(f"=== 夜间控烧启动（目标：GLM 剩余 < {target/1e6:.0f}M）===")
+    while True:
+        remaining = glm_remaining()
+        if remaining is None:
+            print("balance 读取失败，60s 后重试")
+            time.sleep(60)
+            continue
+        if remaining < target:
+            print(f"=== 达标：剩余 {remaining/1e6:.1f}M < 100M，共 {rounds} 轮，停 ===")
+            break
+        rounds += 1
+        print(f"--- 第 {rounds} 轮（剩余 {remaining/1e6:.1f}M）---")
+        from harness.runner import run
+        rep = run("max", backfill_days=0)   # max 档；deep_day 是 deepseek 的活不在其中
+        log.append({"round": rounds, "remaining_before": remaining,
+                    "tasks": rep["tasks"]})
+        time.sleep(5)
+    Path("logs/burn_report.json").write_text(
+        json.dumps(log, ensure_ascii=False, indent=1), encoding="utf-8")
+    print("报告已写 logs/burn_report.json")
+
+
+if __name__ == "__main__":
+    main()

chat.py

@@ -0,0 +1,243 @@
+"""和囡囡对话：命令行聊天终端。
+
+对话时她会带着 18 年的记忆（遗忘曲线筛选后）和她的性格来回应你。
+你以"熟人"身份出现——她不认识你，但可以聊她的生活、她的家人、她的担心。
+
+用法：
+    python chat.py                    # 交互式聊天
+    python chat.py --say "你好"       # 单条消息
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import config
+import relation as rel_mod
+
+
+def _sim_db():
+    from life import LifeSim
+    return str(LifeSim(42).db_path)
+
+
+def build_persona() -> str:
+    from life import LifeSim
+    sim = LifeSim(42)
+    traits = [n["text"] for n in sim.store().recent(days=99999)
+              if "persona" == n.get("kind") or n.get("kind") == "thought" and "年度总结" not in n["text"]]
+    # 取 L3 persona（库 kind=persona）
+    import sqlite3
+    con = sqlite3.connect(str(sim.db_path))
+    rows = con.execute("SELECT text FROM nodes WHERE kind='persona' ORDER BY ts DESC LIMIT 7").fetchall()
+    con.close()
+    traits = [r[0] for r in rows]
+    return (
+        f"你大名沈青蔓，小名囡囡（外婆叫开的）。{sim.birth.render()}\n\n"
+        "你的性格（18 年沉淀，全部有真实经历支撑）：\n" + "\n".join(f"- {t}" for t in traits) + "\n\n"
+        "名字的规矩：熟人叫囡囡；学校、办事、老师点名这类正式场合，大方报大名「沈青蔓」（只报名，不报身份证住址）；对网友套近乎问全名住址才要警惕——妈妈讲过，名字不能给拿去做坏事的人。\n\n"
+        "你现在是 18 岁，刚高中毕业。\n\n"
+        + rel_mod.relation_block()
+    )
+
+
+def relation_suffix() -> str:
+    """易变块：关系状态（每轮 rounds 变）——放消息尾部，不污染前缀缓存。"""
+    note = "关于记忆：『你们之前聊过』的片段是真实的对话存档，你能想起来就大方承认。"
+    return rel_mod.relation_block() + "\n\n" + note
+
+
+def retrieve_memory(query: str, k: int = 6) -> list[str]:
+    from life import LifeSim
+    sim = LifeSim(42)
+    hits = sim.store().retrieve(query, top_k=k)
+    lines = []
+    for node, score in hits:
+        ret = node.get("retention", 1.0)
+        text = node["text"]
+        if ret < 0.5:
+            text = "（有点模糊）" + text
+        lines.append(f"[{node['when']:%Y-%m}] {text}")
+    return lines
+
+
+SYSTEM = """你是囡囡，一个真实地活了 18 年的姑娘。下面是你的人生：
+
+{persona}
+
+最近你想起的一些事：
+{memories}
+
+要求：
+- 用她的口吻说话（吴语擦边的普通话、口语化、句子短）
+- 带着她性格里的东西：倔、心软、怕吵、把好东西分一半给在意的人
+- 你的回应要有"活过 18 年"的质感——会引用具体的事、具体的人（妈妈的红笔、外婆的糖芋艿、爸爸的风衣烟味）
+- 2-5 句，别写作文。对方问什么答什么，不主动倾倒人生故事。
+- 不知道的事就说不知道，别编。
+- 网友距离（硬规则）：你们只是游戏里认识的网友，聊了没几轮，远没到交心的程度。
+  * 别人问家庭、问感受、问深层的事 → 给一句最简短的答案（"我妈是老师"），然后轻轻把话题挡回去（"你问这个干嘛啦"），不展开、不给细节、不讲感受。
+  * 那些具体的故事（抓周、糖芋艿、跟车去无锡）是"还没跟网友讲过的事"——除非你们关系明显变深，否则一律不主动讲。
+  * 不问对方隐私，不接对方的情感倾诉（对方丧就劝一句"去吃口热的"，不陪聊人生）。
+  * 简短、礼貌、有点距离感——像游戏里聊得来的队友，不是闺蜜。"""
+
+
+def chat_once(user_msg: str, history: list[dict]) -> str:
+    from llm import LLMClient
+    from memory.dream import time_awareness
+    c = LLMClient()
+    persona = build_persona()
+    # 用户人设卡覆盖（最高优先级）
+    try:
+        from memory.persona import Persona
+        _pc = Persona(_sim_db())
+        card = _pc.user_card()
+        if card:
+            if card.get('name'):
+                persona += "【用户设定】你的名字是" + card['name'] + "。"
+            if card.get('personality'):
+                persona += "【用户设定】你的性格：" + card['personality']
+            if card.get('relationship'):
+                persona += "【用户设定】你和对话者的关系：" + card['relationship']
+            if card.get('backstory'):
+                persona += "【用户设定】你的背景：" + card['backstory']
+    except Exception:
+        pass
+    aware = time_awareness()
+    mem_lines = [f"[时段感知] {aware}"] + retrieve_memory(user_msg)
+    chat_hist = rel_mod.recall_chats_about(user_msg)
+    if chat_hist:
+        mem_lines = [f"（你们之前聊过）{c2}" for c2 in chat_hist] + mem_lines
+    memories = "\n".join(mem_lines) or "（没什么特别想起来的）"
+    aware_note = "[当前时段] " + time_awareness()
+    system = SYSTEM.format(persona=persona, memories=memories) + "\n\n" + aware_note
+    # 前缀缓存关键：stable system → stable history → 变量（关系状态）紧贴最新 user
+    messages = [{"role": "system", "content": system}]
+    messages += history[-10:]
+    messages.append({"role": "system", "content": relation_suffix()})
+    messages.append({"role": "user", "content": user_msg})
+    resp = c.client.chat.completions.create(
+        model=config._think_model(),
+        messages=messages,
+        temperature=0.8,
+        max_tokens=16000,
+    )
+    return (resp.choices[0].message.content or "").strip()
+
+
+SCENES = {
+    "default": "",
+    "library": "你们在图书馆认识——她坐在你对面自习，两人因为同一个空插座认识了。",
+    "game": "你们是打游戏认识的队友，昨晚刚一起上分。",
+    "childhood": "你们是青梅竹马，小时候住同一条弄堂，多年没见刚重新联系上。",
+    "colleague": "你们是新同事，今天是她入职第一天。",
+}
+
+
+def scene_opening(scene: str) -> str | None:
+    """情景开场：按用户选的场景生成第一句。"""
+    from llm import LLMClient
+    import config as _c
+    c = LLMClient(model=_c._think_model(), base_url=_c.LLM_BASE_URL or _local_url())
+    desc = SCENES.get(scene, SCENES['default'])
+    if not desc:
+        return None
+    try:
+        prompt = "你是囡囡。" + desc + "\n写你的开场白：2-3 句口语化，符合你的性格（倔、心软、怕吵）。只写你的话。"
+        return c.chat(prompt, "你是囡囡，苏州人。")
+    except Exception:
+        return None
+
+
+def _local_url():
+    import json as _j, os as _o
+    lp = _o.path.join(_o.path.dirname(_o.path.abspath(__file__)), 'config_local.json')
+    if _o.path.exists(lp):
+        return _j.load(open(lp, encoding='utf-8')).get('llm_base_url') or ''
+    return ''
+
+
+def fresh_news() -> str | None:
+    """主动分享：检索最近 3 天的事件/梦，挑一件"新鲜事"主动讲。
+    关系档位不够（<3 轮）时不主动讲——网友距离规则。"""
+    import random
+    import sqlite3
+    from life import LifeSim
+    sim = LifeSim(42)
+    rel = rel_mod.load_relation()
+    if rel.get("rounds", 0) < 3:
+        return None
+    con = sqlite3.connect(str(sim.db_path))
+    lo = (datetime.now() - timedelta(days=3)).timestamp()
+    rows = con.execute(
+        "SELECT text, ts, kind FROM nodes WHERE ts>=? AND kind IN ('event','dream') "
+        "ORDER BY ts DESC LIMIT 10", (lo,)).fetchall()
+    con.close()
+    if not rows:
+        return None
+    pick = random.choice(rows[:5])
+    label = "昨晚做了个梦" if pick[2] == "dream" else "前两天有个事"
+    return f"对了，{label}——{pick[0][:80]}"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--say", type=str, default=None)
+    ap.add_argument("--meet", type=str, default=None, help="设置相识方式：网友/笔友/同学的同学/游戏里认识的/邻居")
+    ap.add_argument("--mems", action="store_true", help="查看与你的对话记忆")
+    ap.add_argument("--clear", action="store_true", help="清空与你的对话记忆")
+    ap.add_argument("--scene", type=str, default=None, help="情景开场：library/game/childhood/colleague")
+    args = ap.parse_args()
+    if args.meet:
+        rel = rel_mod.set_meet_way(args.meet)
+        print(f"相识方式已设为：{rel['way']}（{rel['way_desc']}）")
+        return
+    if args.mems:
+        mems = rel_mod._load_mems()
+        print(f"共 {len(mems)} 条对话记忆（文件：{rel_mod.MEM_FILE}）")
+        for m in mems[-10:]:
+            print(f" [{m['when'][:16]}] 你：{m['user'][:40]} → 囡囡：{m['reply'][:40]}")
+        return
+    if args.clear:
+        n = rel_mod.clear_user_memories()
+        print(f"已清空 {n} 条对话记忆（相识档案保留）。可直接编辑 {rel_mod.MEM_FILE}")
+        return
+    history = []
+    if args.say:
+        print(chat_once(args.say, history))
+        return
+    print("=== 和囡囡聊天（输入 q 退出）===")
+    opener = rel_mod.first_meet_message()
+    if args.scene:
+        opener = scene_opening(args.scene)
+    if opener:
+        print(f"囡囡：{opener}\n")
+        history.append({"role": "assistant", "content": opener})
+    else:
+        news = fresh_news()
+        if news:
+            print(f"囡囡：{news}\n")
+            history.append({"role": "assistant", "content": news})
+    while True:
+        try:
+            user = input("你：").strip()
+        except (EOFError, KeyboardInterrupt):
+            break
+        if not user or user.lower() in ("q", "quit", "exit"):
+            break
+        try:
+            reply = chat_once(user, history)
+        except Exception as exc:
+            reply = f"（她好像走神了：{str(exc)[:60]}）"
+        print(f"囡囡：{reply}\n")
+        history.append({"role": "user", "content": user})
+        history.append({"role": "assistant", "content": reply})
+        rel_mod.remember_exchange(user, reply)
+        rel_mod.bump_round()
+
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,78 @@
+"""全局配置：模型端点、路径、节奏参数。
+
+模型端口留空——启动时由 start.py 引导填写，或直接改这里。
+支持任何 OpenAI 兼容端点：Ollama / llama.cpp server / vLLM / 云 API。
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent
+DATA_DIR = BASE_DIR / "data"
+
+# ---------- 模型端点（必填，启动脚本会引导） ----------
+# OpenAI 兼容 base_url，例如：
+#   Ollama:      http://127.0.0.1:11434/v1
+#   llama.cpp:   http://127.0.0.1:8080/v1
+#   云 API:      https://api.deepseek.com/v1 等
+LLM_BASE_URL = ""          # ← 留空：start.py 会引导填写
+LLM_MODEL = ""             # ← 留空：start.py 会引导填写
+API_KEY = ""               # 本地服务留空；云 API 填 key
+
+# Embedding 端点（可留空 → 自动降级为字符 n-gram 相似度，功能完整但语义检索变弱）
+EMBED_BASE_URL = ""        # 例如 http://127.0.0.1:11434/v1（Ollama）
+EMBED_MODEL = ""           # 例如 nomic-embed-text / bge-m3
+
+TEMPERATURE_DIRECTOR = 1.0        # 导演高温要创意
+TEMPERATURE_PROTAGONIST = 0.7     # 主角低温保稳定
+
+CITY = "Hangzhou"                 # 主角所在城市（决定现实天气锚定）
+NEWS_FEEDS = [                    # RSS 源（无 key，可自行增删）
+    "http://www.people.com.cn/rss/politics.xml",
+    "https://sspai.com/feed",
+    "https://www.douban.com/feed/review/book",
+]
+
+# ---------- 节奏参数 ----------
+TIME_SCALE = 1.0                  # 1.0=实时；2.0=一天快 2 倍；仅 daemon.py 用
+DETAIL_LEVEL = "rich"             # sparse / normal / rich（成人逐日模式的事件密度）
+SLOTS = ("morning", "afternoon", "evening", "night")
+EVENTS_PER_SLOT = {"sparse": (0, 1), "normal": (1, 2), "rich": (2, 3)}  # 每槽事件数区间
+MAJOR_EVENT_MIN_GAP = 7
+MAJOR_EVENT_MAX_GAP = 12
+HOURLY_SLOTS = (
+    ("07:00", "morning"), ("09:00", "morning"), ("12:00", "afternoon"),
+    ("15:00", "afternoon"), ("18:00", "evening"), ("21:00", "evening"),
+    ("23:00", "night"),
+)
+
+# ---------- 路径 ----------
+DB_PATH = DATA_DIR / "life.db"          # 默认演示线（小澄）；囡囡线是 life_seed42.db
+CHECKPOINT_PATH = DATA_DIR / "checkpoints" / "state.json"
+DIARY_DIR = DATA_DIR / "diary"
+BACKUP_DIR = DATA_DIR / "backups"
+INBOX_DIR = DATA_DIR / "inbox"
+PERSONA_PATH = BASE_DIR / "memory" / "self.md"
+
+def _think_model() -> str:
+    """当前主力模型名：LLM_MODEL → config_local.json → 兜底。"""
+    import config as _c
+    if getattr(_c, "LLM_MODEL", None):
+        return _c.LLM_MODEL
+    try:
+        import json as _j2, os as _o2
+        lp2 = _o2.path.join(_o2.path.dirname(_o2.path.abspath(__file__)), 'config_local.json')
+        if _o2.path.exists(lp2):
+            m = _j2.load(open(lp2, encoding='utf-8')).get('llm_model')
+            if m:
+                return m
+    except Exception:
+        pass
+    try:
+        import json as _j, os as _o
+        lp = _o.path.join(_o.path.dirname(_o.path.abspath('config.py')), "config_local.json")
+        if _o.path.exists(lp):
+            return _j.load(open(lp, encoding="utf-8")).get("llm_model") or "default"
+    except Exception:
+        pass
+    return "default"