记忆：知识与经验的长期沉淀

# 分层记忆 + 水位线驱逐 + 递归摘要（MemGPT/Letta 核心思路）
MAIN_CTX = [system_instructions, memory_blocks, fifo_queue]   # in-context = RAM
RECALL, ARCHIVAL = db(), vector_db()                          # out-of-context = disk

def step(user_msg):
    fifo_queue.append(user_msg)
    used = count_tokens(MAIN_CTX)

    # 水位线 1：70% 预警，给"LLM 自己"看，让它先抢救要点
    if used > 0.70 * WINDOW:
        fifo_queue.append(sys("memory pressure：把要长期保留的写入 memory_block 或 archival"))

    # 水位线 2：100% 触发 flush（约驱逐半个窗口）
    if used >= WINDOW:
        evicted = fifo_queue.pop_oldest(n=0.5 * WINDOW)       # 不丢弃：转入 recall
        RECALL.insert(evicted)
        running_summary = llm_summarize(running_summary + evicted)   # 有损 + blocking
        fifo_queue.prepend(sys(f"[summary so far] {running_summary}"))

    # LLM 自编辑 + 换页（工具调用），带 heartbeat 则链式续跑
    while True:
        out = llm(MAIN_CTX)
        if out.tool == "archival_memory_insert": ARCHIVAL.add(out.args)   # 写 disk
        elif out.tool == "archival_memory_search": page_in(ARCHIVAL.search(out.q))
        else: return out.reply
        if not out.request_heartbeat: break    # 无 heartbeat 则让出控制，等下次外部事件

CONTEXT_LIMIT = 200_000
PROGRESS = "claude-progress.txt"    # 外部，扛得住重置与 compaction
PLAN     = "features.json"          # [{id, desc, passes:false, priority}]

def long_horizon_agent():
    while not all_done(PLAN):
        # 1) RESUME：只从外部文件重建最小工作状态
        ctx  = read(PROGRESS) + git_log() + read(PLAN)      # O(1) 重读
        task = pick_highest_priority(unfinished(PLAN))

        # 2) ACT：ReAct 循环——轨迹在窗口里，有界、每轮重计费
        traj = []
        while not task.done:
            thought, action = llm(ctx + traj), None
            obs = env(thought.action)
            traj += [thought, obs]
            if tokens(ctx + traj) > 0.7 * CONTEXT_LIMIT:     # 在衰减前外化
                append(PROGRESS, summarize(traj)); traj = traj[-KEEP:]

        # 3) PERSIST：进度写到 context 之外，再让它随意 compact
        set(PLAN, task.id, passes=True)                     # 结构化游标
        append(PROGRESS, f"done: {task.id} — {task.summary}")
        git_commit(f"feat: {task.id}")                      # 持久 checkpoint
    # 任何崩溃/compaction 后：下一次运行重读 PROGRESS+PLAN，不需要历史

def failure_diary_loop(task, max_trials=3):
    memory = store.retrieve(task, k=3)        # 拉回相似任务的过往失败
    for trial in range(max_trials):
        trajectory = actor.run(task, hints=memory)        # 1. 行动（ReAct/CoT）
        signal = oracle.evaluate(trajectory)              # 2. 外部 ground truth：
                                                          #    跑测试 / 编译 / 看工具报错
        if signal.passed:
            return trajectory
        # 3. 反思：把根因 → 一条可复用的纠正规则
        lesson = reflect_llm(trajectory, feedback=signal.error,
                             prompt="为什么失败？给出一条避免它的具体规则。")
        # 4. 存到 context 之外（情景记忆）
        store.save(namespace=("failures", task.kind),
                   value={"obs": task, "result": signal.error, "lesson": lesson})
        memory.append(lesson)                  # 5. 下次重试前注入（有界窗口）
    return escalate_to_human(task)             # 给上限，避免无限自愈空转
# 关键不变式：signal 必须是外部 oracle。模型无 ground truth 自评，反思会让结果更差。