pub fn start_memories_startup_task( // 入口：根会话启动时由 app-server 调用，整条记忆流水线从这里开始    thread_manager: Arc<ThreadManager>, // 线程管理器：Phase2 要靠它派生一个独立的"整理 agent"    auth_manager: Arc<AuthManager>, // 凭证管理：限流护栏和模型 provider 都依赖登录态    thread_id: ThreadId, // 触发流水线的根会话 id（后面认领任务时当 worker id 用）    thread: Arc<CodexThread>, // 根会话句柄：Phase1 采样要读它的上下文    config: Arc<Config>, // 全量配置：模型、记忆参数、feature flag 都从这里取    parent_permission_profile: PermissionProfile, // 父会话权限画像：决定整理 agent 的沙箱上限（第五节）    source: &SessionSource, // 会话来源：子代理会话不允许触发，防止重复抽取) {    if config.ephemeral // 临时会话（如一次性 exec）不产生记忆——没有长期价值        || !config.features.enabled(Feature::MemoryTool) // feature flag 关闭 → 整条流水线禁用        || source.is_non_root_agent() // 子代理一律排除：只有根会话能触发，避免 N 个子 agent 各抽一遍    {        return; // 三个条件命中任意一个就静默跳过——后台任务不打扰用户    }    let versions = if config.memories.dual_write { // dual_write 模式：V1/V2 两条流水线并行跑，用于灰度对比        vec![MemoryVersion::V1, MemoryVersion::V2]    } else {        vec![config.memories.version] // 常规模式：只跑配置里指定的版本    };    for version in versions { // 每个版本有独立记忆根目录（memories/ vs memories_v2/），互不污染        let mut pipeline_config = config.as_ref().clone(); // clone 一份配置，让每条流水线各自改自己的 version 字段        pipeline_config.memories.version = version; // 把这条流水线钉死在目标版本上        let context = Arc::new(MemoryStartupContext::new( // 组装启动上下文：线程管理、凭证、遥测打包在一起            Arc::clone(&thread_manager), // 共享同一个线程管理器（Arc clone，不深拷贝）            Arc::clone(&auth_manager), // 共享登录凭证            thread_id, // 记录是哪个根会话触发的            Arc::clone(&thread), // 根会话句柄            config.as_ref(), // 已钉版本的配置            source.clone(), // 会话来源（遥测归因用）        ));        tokio::spawn(async move { // 后台任务：完全不阻塞用户当前这一轮对话            if context.memory_store().await.is_none() { // state DB 不可用 → 流水线没法跑（认领任务全靠它）                warn!("state db unavailable for memories startup pipeline; skipping"); // 记日志退出，不向调用方抛错                return;            }            let root = config.codex_home.join(config.memories.version.directory_name()); // 记忆根：~/.codex/memories 或 memories_v2            if let Err(err) = ensure_layout(&root).await { // 建目录结构，且拒绝符号链接根（防止记忆文件被重定向到别处）                warn!("failed preparing memories root: {err}");                return;            }            phase1::prune(context.as_ref(), &config).await; // 先清理过期 raw memory——纯 DB 操作不烧 token，所以放在限流检查之前            if !guard::rate_limits_ok(&auth_manager, &config).await { // 限流护栏：Codex 配额快用完就跳过本轮（下面细看）                context.counter(MEMORY_STARTUP, /*inc*/ 1, &[("status", "skipped_rate_limit")]); // 记一条 skipped 指标，方便观测                return;            }            phase1::run(Arc::clone(&context), Arc::clone(&config)).await; // Phase1：并行抽取 raw memory（第二节）            phase2::run(context, config, parent_permission_profile).await; // Phase2：全局锁下合并成可注入摘要（第四节）        });    }}

fn snapshot_allows_startup(snapshot: &RateLimitSnapshot, min_remaining_percent: i64) -> bool { // 判断当前配额是否够跑记忆生成    if snapshot.rate_limit_reached_type.is_some() { return false; } // 已触发硬限流 → 直接跳过，不浪费一次请求    let max_used_percent = 100.0 - min_remaining_percent.clamp(0, 100) as f64; // 把"最少保留百分比"换算成"最多允许用掉百分之几"    window_allows_startup(snapshot.primary.as_ref(), max_used_percent) // 主窗口（5 小时配额）必须达标        && window_allows_startup(snapshot.secondary.as_ref(), max_used_percent) // 次窗口（周配额）也要达标——两个窗口都够才放行}fn window_allows_startup(window: Option<&RateLimitWindow>, max_used_percent: f64) -> bool { // 单个窗口的判定    match window {        Some(window) => window.used_percent <= max_used_percent, // 已用百分比 ≤ 阈值 → 允许        None => true, // 该窗口没有数据 → 不拦（fail-open：宁可多跑一次，也不因缺数据卡死功能）    }}

    futures::stream::iter(claimed_candidates) // 把认领到的会话列表变成流        .map(|claim| { // 每个 claim（一个历史会话）变成一个独立 async 任务            let context = Arc::clone(&context); // 共享启动上下文（Arc clone，不深拷贝）            let config = Arc::clone(&config); // 配置同理            let stage_one_context = stage_one_context.clone(); // 遥测上下文 Clone 很便宜            async move { job::run(context.as_ref(), config.as_ref(), claim, &stage_one_context).await } // 执行单个会话的抽取        })        .buffer_unordered(crate::stage_one::CONCURRENCY_LIMIT) // 并发上限 8：并行但不失控，避免打爆模型 API        .collect::<Vec<_>>() // 收集全部结果——顺序无所谓，每个 job 写自己的 DB 行，互不依赖        .await

    async fn sample( // 单会话抽取核心：读 rollout → 序列化 → 拼 prompt → 调模型 → 解析结构化输出        context: &MemoryStartupContext,        config: &Config,        rollout_path: &Path, // 该会话的 rollout 录制文件路径（JSONL）        rollout_cwd: &Path, // 当时的工作目录——帮模型判断这条记忆属于哪个项目        rollout_git_branch: Option<&str>, // git 分支：V2 输入会带上，用于限定记忆的适用范围        stage_one_context: &StageOneRequestContext,    ) -> anyhow::Result<(StageOneOutput, Option<TokenUsage>)> {        let (rollout_items, _, _) = RolloutRecorder::load_rollout_items(rollout_path).await?; // 反序列化整段会话录制（复用 rollout crate 的加载逻辑）        let rollout_contents = match config.memories.version { // V1/V2 两套序列化策略            MemoryVersion::V1 => serialize_filtered_rollout_response_items(&rollout_items)?, // V1：扁平序列化全部 item，简单直接            MemoryVersion::V2 => crate::rollout_input::serialize_tiered_input( // V2：分层预算分配（第三节细拆）                &rollout_items,                crate::prompts::rollout_token_limit(&stage_one_context.model_info), // token 上限 = 模型上下文窗口的 70%（留 30% 给系统提示和输出）            )?,        };        let mut prompt = Prompt::default(); // 构造一个"结构化输出"请求        prompt.input = match config.memories.version { // V1 单条 user message；V2 切成多条 contextual fragment（避免单条超长）            MemoryVersion::V1 => vec![ResponseItem::Message { /* …user 消息，内容即 input_text… */ }],            MemoryVersion::V2 => crate::rollout_input::extraction_messages(&input_text), // 按字符边界切成 ≤8900 字节的多条片段        };        prompt.base_instructions = BaseInstructions { // 系统提示是内嵌模板文件（include_str!），版本各一份            text: match config.memories.version {                MemoryVersion::V1 => crate::stage_one::PROMPT, // V1：templates/memories/stage_one_system.md                MemoryVersion::V2 => include_str!("../templates/memories/stage_one_system_v2.md"), // V2 模板强调"写任务史不写用户画像、区分证据与猜测"            }.to_string(),            provenance: None,        };        prompt.output_schema = Some(output_schema(config.memories.version)); // 强制模型按 JSON Schema 输出（raw_memory + rollout_summary）        prompt.output_schema_strict = true; // strict 模式：不允许多余字段——下游解析依赖固定形状        let (result, token_usage) = context.stream_stage_one_prompt(config, &prompt, stage_one_context).await?; // 流式调用抽取模型（Low reasoning effort，控制成本）        let output = StageOneOutput::parse(&result, config.memories.version)?; // 解析并校验结构化输出        Ok((output, token_usage)) // 连同 token 用量一起返回——后面要进指标账本    }

        if stage_one_output.raw_memory.as_ref().is_some_and(String::is_empty) // raw memory 是空串 → 视为无产出            || stage_one_output.rollout_summary.is_empty() // 或者摘要为空 → 这个会话没有值得记的东西        {            return JobResult { outcome: result::no_output(context, claimed_thread.id, &claim.ownership_token).await, token_usage }; // 释放认领（标记 no-output），不写 DB——避免垃圾记忆污染 Phase2 输入        }        JobResult { // 有产出 → 落库：raw_memory + rollout_summary + slug 一起写入 stage1_outputs 表            outcome: result::success(                context,                claimed_thread.id, // 关联源会话 id——将来引用回写"使用记录"就靠它（第六节）                &claim.ownership_token, // 所有权令牌：只有认领者能写这行，防并发竞争                claimed_thread.updated_at.timestamp(), // 输入水位线用会话更新时间戳                stage_one_output.raw_memory.as_deref().unwrap_or_default(),                &stage_one_output.rollout_summary,                stage_one_output.rollout_slug.as_deref(),            ).await,            token_usage,        }

        let tier = match &item { // 给每条 item 定级——决定预算紧张时谁先被保留（六级见下方卡片）            ResponseItem::FunctionCallOutput { .. } if question.is_some() => Tier::Human, // 用户对模型提问的回答 → 最高优先级"人类证据"（前面已把问答配对）            ResponseItem::AgentMessage { .. } => Tier::OtherAgent, // 其他 agent 发来的消息（多智能体场景）            ResponseItem::Message { role, content, phase, internal_chat_message_metadata_passthrough, .. } => { // 普通消息：按角色和元数据细分                let agent_content = internal_chat_message_metadata_passthrough // 先看元数据标记：是否带 multi_agent.* 前缀（agent 间通信）                    .as_ref()                    .and_then(|metadata| metadata.content_item_kinds.as_ref())                    .is_some_and(|kinds| kinds.iter().any(|kind| kind.0.starts_with("multi_agent."))) // 命中 → 按 agent 消息处理                    || InterAgentCommunication::is_message_content(content) // 或者内容本身就是 agent 间通信结构                    || content.iter().any(|part| match part { // 再兜底：文本前缀嗅探（兼容旧格式）                        ContentItem::InputText { text } | ContentItem::OutputText { text } => {                            let text = text.trim_start();                            text.starts_with("<subagent_notification>") // subagent 通知标记 → OtherAgent 级                                || (text.starts_with("Message Type:") && /* …Task name/Sender/Payload 三行头格式… */) // 旧版 agent 消息的固定头部                        }                        _ => false,                    });                if agent_content { Tier::OtherAgent } // agent 间通信 → 第二优先级（信息密度高但不是用户原话）                else if role == "user" { // user 消息：要区分"真人输入"和"harness 注入的上下文"                    let contextual = internal_chat_message_metadata_passthrough.as_ref() // user 角色也可能是框架注入的（如环境上下文）                        .and_then(|metadata| metadata.content_item_kinds.as_ref())                        .is_some_and(|kinds| !kinds.is_empty() && kinds.iter().all(|kind| !kind.0.starts_with("user."))) // 元数据不带 user.* 前缀 → 不是真人输入                        || content.iter().any(|part| matches!(part, ContentItem::InputText { text } // 或者文本被 <environment_context> 标记包裹                            if matches_marked_fragment(text, "<environment_context>", "</environment_context>"))); // 命中 → 框架上下文级（最低档之一）                    if contextual { Tier::Context } // 环境/系统注入的"伪 user"消息 → 低优先级                    else { Tier::Human } // 真人说的话 → 最高优先级，预算再紧也先保它                } else if matches!(phase, Some(MessagePhase::Commentary)) { Tier::Commentary } // assistant 的过程性评论（思考旁白）                else { Tier::Final } // assistant 的最终回答            }            _ => Tier::Tool, // 工具调用与输出 → 最低级（最冗长、信息密度最低，最先被砍）        };

    let mut remaining = approx_bytes_for_tokens(token_limit).saturating_sub(OMITTED.len()); // 总预算：token 上限换算成字节，先预留"省略占位符"的空间    let mut selected = vec![None; rows.len()]; // 占位数组：None 表示该行最终被省略    for tier in [Tier::Human, Tier::Final, Tier::OtherAgent, Tier::Commentary, Tier::Context, Tier::Tool] { // 按优先级从高到低分配——高级别先吃饱        for (index, (row_tier, text)) in rows.iter().enumerate().rev() { // 同级内部从新到旧（倒序）取——最近的证据更有价值            if *row_tier != tier || remaining <= OMITTED.len() + TRUNCATION_RESERVE_BYTES { continue; } // 不是这一级、或预算不够放一条 → 跳过            let budget = remaining - OMITTED.len(); // 给这一行的可用额度            let text = if text.len() <= budget { text.clone() } else { truncate_text(&text, TruncationPolicy::Bytes(budget - TRUNCATION_RESERVE_BYTES)); }; // 超预算 → 硬截断到刚好放下            remaining = remaining.saturating_sub(text.len() + OMITTED.len()); // 扣减剩余预算（saturating 防下溢）            selected[index] = Some(text); // 标记为选中        }    }    let mut rendered = String::new(); // 最终输出缓冲    let mut gap = false; // 是否正处于"省略区间"内（避免连续插占位符）    for row in selected { // 按原始时间顺序重新拼装——模型看到的是会话时间线，不是优先级排序        match row {            Some(text) => { rendered.push_str(&text); gap = false; } // 选中行：原样追加            None if !gap => { rendered.push_str(OMITTED); gap = true; } // 被省略的区间：插一个 "[... response items omitted ...]" 标记，告诉模型这里缺东西            None => {} // 连续省略不重复占位符        }    }

pub async fn run( // Phase2 主流程：严格线性，任一步失败 → 标记 job failed（带重试延迟）后返回    context: Arc<MemoryStartupContext>,    config: Arc<Config>,    parent_permission_profile: PermissionProfile, // 父会话权限画像：决定整理 agent 的沙箱上限（第五节）) {    let root = config.codex_home.join(config.memories.version.directory_name()); // 记忆根目录（memories/ 或 memories_v2/）    // 1. Claim the global Phase 2 lock before touching the memory workspace.    let claim = match job::claim(context.as_ref(), &db).await { // 全局锁：跨机器、跨会话只允许一个 consolidation 在跑；输家拿到 Skipped* 直接退出        Ok(claim) => claim,        Err(e) => { context.counter(MEMORY_PHASE_TWO_JOBS, /*inc*/ 1, &[("status", e)]); return; } // 认领失败（cooldown/running/retry_unavailable）→ 记指标退出，不重试    };    if let Err(err) = prepare_memory_workspace(&root).await { // 2. 确保记忆根有 git baseline 仓库——用来 diff"这次输入到底变没变"        job::failed(context.as_ref(), &db, &claim, "failed_prepare_workspace").await; return; // 失败 → 标记 failed（3600s 后允许重试）并退出    }    let Some(agent_config) = agent::get_config(config.as_ref(), parent_permission_profile, context.provider()) else { // 3. 构造整理 agent 的"锁死配置"（第五节细拆）        job::failed(context.as_ref(), &db, &claim, "failed_sandbox_policy").await; return;    };    let raw_memories = match db.get_phase2_input_selection(max_raw_memories, max_unused_days).await { // 4. 从 DB 取 Phase1 产出：条数封顶 + 按"最近使用天数"过滤        Ok(raw_memories) => raw_memories,        Err(err) => { job::failed(context.as_ref(), &db, &claim, "failed_load_stage1_outputs").await; return; }    };    let new_watermark = get_watermark(claim.watermark, &raw_memories); // 新水位线：本批输入的最大更新时间戳——记录"合并到哪了"    if let Err(err) = sync_phase2_workspace_inputs(&root, &raw_memories, &config).await { // 5. 把 DB 数据落成工作区文件（rollout_summaries/ + raw_memories.md），并清理过期 extension 资源        job::failed(context.as_ref(), &db, &claim, "failed_sync_workspace_inputs").await; return;    }    let workspace_diff = match memory_workspace_diff(&root).await { // 6. git diff 对比 baseline：输入文件到底有没有变化？        Ok(diff) => diff,        Err(err) => { job::failed(context.as_ref(), &db, &claim, "failed_workspace_status").await; return; }    };    if !workspace_diff.has_changes() && validate_consolidation_artifacts_for_version(&root, config.memories.version).await.is_ok() { // 没变化且现有产物合法 → 根本不用调模型        job::succeed(context.as_ref(), &db, &claim, new_watermark, &raw_memories, "succeeded_no_workspace_changes").await; return; // 直接标记成功（水位线照常推进）——这是 Phase2 最大的省钱点    }    if let Err(err) = write_workspace_diff(&root, &workspace_diff).await { // 7. 把 diff 落盘成 phase2_workspace_diff.md，让 agent 先读"这次改了什么"再动手        job::failed(context.as_ref(), &db, &claim, "failed_workspace_diff_file").await; return;    }    let prompt = agent::get_prompt(&root, config.memories.version); // 8. 构造 consolidation prompt（模板 + 记忆根路径）    let agent = match context.spawn_consolidation_agent(agent_config, prompt).await { // 派生一个独立的 Codex 线程当"整理工人"        Ok(agent) => agent,        Err(err) => { job::failed(context.as_ref(), &db, &claim, "failed_spawn_agent").await; return; }    };    agent::handle(Arc::clone(&context), claim, new_watermark, raw_memories.clone(), root, config.memories.version, agent, phase_two_e2e_timer); // 9. 交给后台任务：心跳轮询 → 产物校验 → baseline 重置 → 标记成功}

    pub(super) fn get_config( // 为整理 agent 构造"锁死配置"——每一行都是安全边界        config: &Config,        parent_permission_profile: PermissionProfile,        provider: &dyn ModelProvider,    ) -> Option<Config> {        let root = config.codex_home.join(config.memories.version.directory_name()); // 唯一允许写入的目录：记忆根        let mut agent_config = config.clone(); // 从父配置拷贝起步，再逐项收紧        agent_config.cwd = root.clone(); // 工作目录钉死在记忆根——shell 命令默认在这里执行        agent_config.ephemeral = true; // 临时会话：它自己的 rollout 不录制（防止 worker 的产出反过来成为 Phase1 输入）        agent_config.memories.generate_memories = false; // 关掉它自己的记忆生成——否则无限递归（worker 生记忆 → 再触发一个 worker）        agent_config.memories.use_memories = false; // 也不注入现有记忆：整理必须基于 raw 输入，而不是旧摘要套娃        agent_config.notify = None; // 后台工作绝不发用户可见的完成通知        agent_config.include_apps_instructions = false; // 不带 apps 指令——与整理任务无关        agent_config.mcp_servers = Constrained::allow_only(HashMap::new()); // MCP server 全禁：worker 只需要读写本地文件        agent_config.permissions.approval_policy = Constrained::allow_only(AskForApproval::Never); // 永不请求审批：没有人在场，而且它本就不该需要        let _ = agent_config.features.disable(Feature::Collab); // 禁用多智能体协作——worker 不得再委派子任务（递归爆炸）        let _ = agent_config.features.disable(Feature::MemoryTool); // 禁用记忆工具（list/read/search）：输入已同步到磁盘，直接 shell 读即可        let _ = agent_config.features.disable(Feature::Apps); // 禁 apps        let _ = agent_config.features.disable(Feature::Plugins); // 禁 plugins——最小化攻击面        match parent_permission_profile { // 沙箱策略：尊重父会话的显式选择，Managed 模式则收紧到"只写记忆根 + 无网络"            PermissionProfile::Disabled => agent_config.permissions.set_permission_profile(PermissionProfile::Disabled), // 父级显式禁用沙箱 → 照办（用户自担风险）            PermissionProfile::External { network } => agent_config.permissions.set_permission_profile(PermissionProfile::External { network }), // 外部托管画像 → 原样继承            PermissionProfile::Managed { .. } => { // Codex 托管模式：收缩为最小权限                agent_config.set_legacy_sandbox_policy(SandboxPolicy::WorkspaceWrite {                    writable_roots: vec![root], // 只有记忆根可写——其他目录一律只读                    network_access: false, // 无网络访问：整理是纯本地文件操作，联网毫无必要                    exclude_tmpdir_env_var: true, // $TMPDIR 豁免（标准临时目录惯例）                    exclude_slash_tmp: true, // /tmp 也豁免                })            }        }.ok()?; // 任何一步失败 → 返回 None，调用方标记 job failed        agent_config.model = Some(            config.memories.consolidation_model.clone() // 模型可显式配置（通常配更强的）                .unwrap_or_else(|| provider.memory_consolidation_preferred_model().to_string()), // 未配置 → 用 provider 推荐的整理专用模型        );        agent_config.model_reasoning_effort = Some(crate::stage_two::REASONING_EFFORT); // Medium：比 Phase1 的 Low 高一档——合并去重是更难的任务        Some(agent_config)    }

            let instructions = match config.version { // V1 整段注入；V2 切分成多个 fragment                MemoryVersion::V1 => vec![instructions], // V1：单条 developer policy，简单直接                MemoryVersion::V2 => { // V2：受"每片段字节上限"约束，必须切分                    let mut remaining = instructions.as_str(); // 尚未切分的剩余文本                    let mut fragments = Vec::new();                    while !remaining.is_empty() { // 循环切到空为止                        let end = remaining.floor_char_boundary(remaining.len().min(8_900)); // 每段 ≤8900 字节，且落在字符边界上（不劈开多字节 UTF-8）                        fragments.push(MemoryContextFragment::ReadInstructions(remaining[..end].to_string()).render()); // 包成"读取说明"片段并渲染                        remaining = &remaining[end..]; // 推进到下一段                    }                    fragments                }            };            instructions.into_iter()                .map(|instructions| PromptFragment::developer_policy( // 每个片段都标记为 developer policy（系统级指令，优先级高于 user）                    instructions,                    ContentItemKind("memories.instructions".to_string()), // 统一命名空间——初始摘要和检索工具必须用同一版本（见 on_config_changed）                ))                .collect()

pub fn parse_memory_citation(citations: Vec<String>) -> Option<MemoryCitation> { // 把模型输出的引用标记解析成结构化对象    let mut entries = Vec::new(); // 引用条目：path + 行号范围 + note（"这条记忆说了什么"）    let mut rollout_ids = Vec::new(); // 源会话 id 列表——回写使用记录的关键    let mut seen_rollout_ids = HashSet::new(); // 去重集合    for citation in citations { // 模型可能输出多段引用标记，逐段解析        if let Some(entries_block) = extract_block(&citation, "<citation_entries>", "</citation_entries>") { // 提取条目块（自定义标签，不是 HTML——纯文本协议）            entries.extend(entries_block.lines().filter_map(parse_memory_citation_entry)); // 逐行解析成结构化 entry        }        if let Some(ids_block) = extract_ids_block(&citation) { // 提取源会话 id 块（兼容 rollout_ids / thread_ids 两种旧标签）            for id in ids_block.lines().map(str::trim).filter(|line| !line.is_empty()) {                if seen_rollout_ids.insert(id.to_string()) { // HashSet insert 返回 false = 已存在 → 跳过重复                    rollout_ids.push(id.to_string());                }            }        }    }    if entries.is_empty() && rollout_ids.is_empty() { None } else { Some(MemoryCitation { entries, rollout_ids }) } // 什么都没解析出来 → None（调用方当"没引用记忆"处理）}fn parse_memory_citation_entry(line: &str) -> Option<MemoryCitationEntry> { // 单行格式：path:start-end|note=...    let line = line.trim();    if line.is_empty() { return None; }    let (location, note) = line.rsplit_once("|note=[")?; // 从右往左切出 note（路径里可能含 |，rsplit 才安全）    let note = note.strip_suffix(']')?.trim().to_string();    let (path, line_range) = location.rsplit_once(':')?; // 再切出 path 和行号范围    let (line_start, line_end) = line_range.split_once('-')?;    Some(MemoryCitationEntry { path: path.trim().to_string(), line_start: line_start.trim().parse().ok()?, line_end: line_end.trim().parse().ok()?, note }) // 解析失败任何一环 → None，整行丢弃（宽容解析）}

async fn record_stage1_output_usage_and_detect_memory_citation( // 每条 assistant 消息后调用：检测是否引用了记忆，是则回写"使用记录"    state_db_ctx: Option<&codex_state::MemoryStore>,    item: &ResponseItem,) -> bool {    let Some(raw_text) = raw_assistant_output_text_from_item(item) else { return false; }; // 只处理 assistant 文本消息（工具输出不算）    let (_, citations) = strip_citations(&raw_text); // 先把引用标记从可见文本里剥掉——用户看到的回复不含这些内部标记    let Some(memory_citation) = parse_memory_citation(citations) else { return false; }; // 解析失败或没有记忆引用 → 什么都不做    record_stage1_output_usage_for_memory_citation(state_db_ctx, &memory_citation).await}async fn record_stage1_output_usage_for_memory_citation( // 回写"使用"——这是 Phase1 prune（max_unused_days）的唯一依据    state_db_ctx: Option<&codex_state::MemoryStore>,    memory_citation: &MemoryCitation,) -> bool {    let thread_ids = thread_ids_from_memory_citation(memory_citation); // 引用里的 rollout_ids → ThreadId（解析失败的 id 直接丢弃）    if thread_ids.is_empty() { return true; } // 没有可追溯的源会话 → 跳过    if let Some(db) = state_db_ctx {        let _ = db.record_stage1_output_usage(&thread_ids).await; // 更新对应 Phase1 输出行的 last_used_at——"被用过"的记忆不会被 max_unused_days 剪掉    }    true}

写路径（启动时后台流水线）

▼

▼

▼

▼

▼

读路径（每个新会话）

▼

▼