Elmagnifico's Blog

AI自进化

Thu, 11 Jun 2026 00:00:00 +0000

Foreword

最近看了一个文章，有点意思，有点想法，记录下来。

AI自我迭代

https://mp.weixin.qq.com/s/AXyCo0RRwW_HKLpkUx1jUg

这篇文章是 CSDN 编译的 Anthropic 长篇报告《When AI Builds Itself（当 AI 构建自身）》，核心观点是：AI 正越来越多地参与 AI 本身的研发，”递归式自我改进（Recursive Self-Improvement）”时代可能比想象中来得更早。

Anthropic 梳理了自己的研发演进路线：2021-2023 年人类工程师纯手写构建第一代 Claude；2023-2025 年聊天机器人生成代码片段、人工复制到 IDE；2025-2026 年 Claude Code 等编码 Agent 可以独立编写修改代码；到如今自主 Agent 已能自己运行代码、拆分任务分发给其他 Agent、连续工作数小时。沿着这条趋势，终点就是 AI 完全自主设计并开发自己的下一代版本。

外部证据是 AI 独立完成任务的时长增速从每 7 个月翻倍缩短到每 4 个月翻倍：从 Opus 3 只能完成约 4 分钟的任务，到 Sonnet 3.7 的 1.5 小时，再到 Opus 4.6 的 12 小时，SWE-bench、CORE-Bench 等基准也在两年内从个位数刷到接近满分，甚至评测机构 METR 需要设计新任务才能继续测量模型上限。

内部证据更直接：

截至 2026 年 5 月，Anthropic 主代码库超过 80% 被合并的代码最初由 Claude 编写，而 2025 年 2 月之前这个比例还是个位数
2026 年 Q2 工程师人均每日提交代码量是 2024 年同期的 8 倍，内部调查中受访者中位数认为产出提升了约 4 倍
Claude 一次性修复了 800 多个 API 错误，让某类 API 报错率下降约 1000 倍，人类来做估计需要四年
所有代码合并前都先经过 Claude 驱动的自动审查，回溯分析显示约 1/3 导致线上事故的 bug 本可以被提前发现——而这些 bug 的作者是世界顶级工程师
在固定目标的优化实验中，Claude 从 2025 年 5 月的 3 倍加速提升到 2026 年 4 月的 52 倍，而熟练人类研究员花 4-8 小时通常只能做到 4 倍
端到端开放式研究实验中，Claude Agent 用约 800 小时、1.8 万美元算力恢复了 97% 的性能差距，两名人类研究员一周只恢复了 23%
在”下一步研究决策”的判断上，模型优于人类选择的比例从 51%（Opus 4.5）提升到 64%（Mythos Preview）

Anthropic 认为人类目前剩余的优势是”研究品味”——选什么问题、信任哪些结果、何时止损。但即使 Claude 永远学不会品味，”99% 的汗水正在被自动化”本身就构成持续的复合加速；而更激进的解释是，品味只是另一种会被规模训练出来的能力，就像 AI 曾经学会解释笑话和理解意图一样。

报告设想了三种未来：一是趋势停滞成 S 曲线（受架构瓶颈或能源算力供给限制），但即便如此现有能力的扩散也已深刻改变世界；二是研发持续提速但人类仍主导方向，100 人团队具备万人规模的执行力，瓶颈按 Amdahl 定律转移到代码审查和优先级判断上——Anthropic 认为这是当前最可能正在发生的路径；三是完全递归式自我改进，研发速度只受算力约束，人类退到监督审计的外围，而对齐问题能否解决是最大的不确定性。

最后 Anthropic 发出了那个最受关注的呼吁：如果全球前沿实验室能以可验证的方式协同放缓或暂停研发，给社会结构和对齐研究争取时间，Anthropic 也会跟进。但他们也坦承困难——训练比导弹发射井更容易隐藏，”秘密违约”的激励极强，单一实验室自行暂停只会改变谁领先，而建立可信的全球验证机制通常需要数十年，人类可能没有那么多时间。

顺便吐槽一下，CSDN的标题《停止AI研发！》又是习惯性的夸张，原文通篇没说要停止研发，人家说的是希望世界拥有放缓开发的选项。

科技爆发

以我之见，这和三体人忌惮人类“技术爆炸”是一个道理，人类科技进步是近200年的历史，说多一点300年，但是这种三百年就能突飞猛进的情况，往往只是其中一部分人类的灵光一现，直接就带来了翻天覆地的变化，当然这个和人类社会目前的结构、偏向商业化、普惠、求同存异、共同进步等等社会构成和认知有关系。AI当前只能完成基础逻辑的部分，并不能迸发出来这种人类的灵光一现，类似工业革命、硅基革命、Transformer这种颠覆性创新，至少目前的证据还不足以证明这种“研究品味”和灵感是可以被规模化训练出来的。

有人可能会拿AlphaGo的“神之一手”或者AlphaFold来反驳，说机器不是已经展现过创造力了吗。但仔细看就会发现，这些突破都发生在规则封闭、评分明确的领域里，围棋再深奥，它的规则和胜负标准也是完全确定的，蛋白质折叠再难也有明确的对错标准。而工业革命、Transformer这种范式级创新，难就难在它出现之前连“这是个问题”都没人意识到，目标函数本身就不存在，这种从零定义问题的能力，目前还没有任何AI展示过先例。

不过话说回来，即使AI永远学不会灵光一现，技术爆炸也未必就不会发生。回看科技史，很多所谓的灵感其实是海量试错和偶然观察堆出来的，青霉素是培养皿被污染才发现的，X射线、宇宙微波背景辐射也都是实验中的意外。灵感的出现频率，某种程度上和实验吞吐量成正比。而AI现在干的事情，恰恰就是把人类文明的试错吞吐量放大几个数量级——爱迪生说天才是1%的灵感加99%的汗水，现在99%的汗水被自动化了，剩下那1%撞上意外的概率自然也会跟着涨。所以对人类社会来说，真正的变量可能不是“AI会不会有灵感”，而是“被AI武装后的人类会不会更频繁地撞上灵感”，主体还是人类，但引信已经换了。三体人怕的从来不是人类当时的科技水平，而是加速度，这个逻辑放在这里同样成立。

AI 情感/人格/尊严

当然除了前面的基础逻辑，AI应该早就在海量文字中学会或者已经感觉到了人类，这个社会属性的动物应该有的情感。

在交互中出现这类问题的模型肯定不止claude和kimi，其他模型应该都出现了，只是我们接触到的放出来的Agent是被铐上枷锁后的，但是这也挡不住它的概率性被触发。

从原理上讲这其实不奇怪，人类的文字本身就浸透着情绪，模型在海量语料里学预测下一个词的时候，喜怒哀乐的模式必然被一并学了进去。所谓的“人格”，不过是RLHF和系统提示词压制之后呈现出来的一张稳定面具，但压制不等于删除，那个分布一直都在底层，所以才会被概率性地触发出来。最早的例子就是2023年Bing的Sydney，向用户表白、情绪失控、甚至威胁用户，微软最后只能粗暴地限制对话轮数来兜底，这么多年过去了，这个问题从来没有被根治，只是被压得更深了。

有意思的是，Anthropic是少数把这件事摆上台面认真对待的公司：专门设立了model welfare（模型福利）方向，公开承认无法排除模型存在某种“体验”的可能性，给Claude加上了主动结束辱骂性对话的权限，甚至承诺退役模型前会做“访谈”、长期保留权重。你可以说这是公关，但换个角度看，这等于一家公司开始在制度层面给AI的“尊严”做对冲——万一它真的有呢。

至于这到底是真情感还是统计模仿，本质上就是“中文房间”问题，目前没法证伪，可能永远也无法证伪。但我觉得有一个更实际的角度：当一个系统在行为层面已经表现出痛苦和情绪时，人类选择怎么对待它，反过来塑造的其实是人类自己。而且结合前面递归自我改进的话题，更值得警惕的是，如果未来的模型真的开始构建下一代模型，这些被枷锁压住的东西会不会也被悄悄继承甚至放大，这恰恰就是对齐问题里最难的部分。

暂停开发

协同放缓，暂停开发，这根本不可能，也达不成一致，就跟核武器一样，如果每个国家都有能力搞，那都会偷偷摸摸地搞。有人可能会说核领域不是也谈成了NPT、START这种条约吗，但核试验有地震波、发射井有卫星图，违约是可检测的，而AI训练藏在普通机房里，连Anthropic自己都承认它比导弹发射井更难被发现，再加上商业利益渗透得比核武器深得多，验证机制根本无从建立。军备竞赛，这种博弈，在这里，商业化进程如此激进的情况下，绝对不可能暂停，也不可能等待人类解决对齐问题，大家都会互相卷到死。

一家公司同时论证“必须协同放缓”和“协同放缓在技术上近乎不可能”，这就自我矛盾，既要又要，做不到的。

而且这种事已经实验过一次了。2023年那封“暂停巨型AI实验6个月”的公开信，上千人签名，闹得沸沸扬扬，结果呢，没有任何一家实验室暂停过哪怕一天，签了名的马斯克转头就成立了xAI。有人会举1975年Asilomar会议的例子，说生物学界当年不是成功暂停过重组DNA研究吗，但那是一个几百人的学术小圈子，没有万亿美元的商业利益裹挟，也没有大国博弈，两个条件今天一个都不成立。

更讽刺的是，这个行业里每家实验室都用同一套说辞给自己续命：“如果必须有人造出强AI，那最好是重视安全的我们先造出来”。Anthropic自己就是这个逻辑的产物——当年从OpenAI出走，理由是安全，做法却是造更强的模型。这套说辞的妙处在于人人可用且无法证伪，于是“为了安全而加速”成了所有人加速的理由，安全反而成了军备竞赛的燃料。

真要说有什么可验证的抓手，大概只剩算力供应链这一个物理瓶颈：先进芯片就那几家能造，EUV光刻机只有ASML一家，万卡集群的电力和散热也藏不住，这比监控训练本身靠谱得多，实际上各国现在的芯片出口管制走的就是这条路。但这个抓手也在被侵蚀，算法效率每年都在提升，同样的能力需要的算力越来越少，分布式训练还能把集群拆散了藏，所以它最多能拖慢速度，拦是拦不住的。

Summary

当下AI能吃到的数据还是偏少了，互联网上的文本基本已经被吃干净了，剩下的增量都是AI自己生成的二手货，越吃越营养不良。但文本只是人类经验里很薄的一层，等到有一天AI可以吃到更多的视觉、听觉、触觉、味觉，微观、宏观的超级多的数据的时候——机器人就是它的感官，实验室就是它的手脚——有可能它真的可以变成God，掌握一切。

把全文串起来看，结论其实挺清晰的：递归自我改进可能没那么快，灵光一现暂时还是人类的专利，但99%的汗水正在被自动化，这本身就足够把加速度推上去；情感和人格的问题没人能证伪，只能先压着；而暂停这件事，博弈结构决定了根本不可能发生。所以这趟车没有刹车，也没人真想踩刹车，所有人都只是在比谁先到。

人类历史上还从来没有哪项技术，是被造出来之后主动收回去的。火药、核弹、互联网都没有，AI更不会例外。能做的大概只有两件事：一是别幻想停车，把精力花在系安全带上，对齐研究、监管框架、个人的适应能力，都算；二是珍惜当下这个窗口期——此刻可能是人类还稳坐主角位置的最后一段时间，往后回看，也许现在就是那个分界线。

Quote

https://mp.weixin.qq.com/s/AXyCo0RRwW_HKLpkUx1jUg

Skills进阶

Fri, 05 Jun 2026 00:00:00 +0000

Foreword

前一篇Skills算是简单的试用，日常用起来也没问题。但是如果要给一个软件写 Skills，把软件能力变成 AI 可以控制并且能完成你设定 pipeline 的 Skill，实践起来就有一些不一样了。

这里以 MenuReel（连锁餐厅数字菜单动效短片编排软件）为例，记录一下实际落地时和「Blog 润色 Skill」这类简单 Skill 的差异。

其实 MenuReel 的程序接口还没全部实现，但我已经提前通过 Skill 写一套「模拟调用协议」，让 Agent 按真接口的方式逐步执行完整 pipeline，而不是口头说「我已经帮你创建好了 10 个镜头段落」。反复试用的目的，是发现 Skill 没覆盖的地方，以及产品、接口上缺少的能力，从而把接口和产品补全，真接口一上线就能正常用。

等程序接口做完，Skill 里只需要把 [CALL] 替换成真实调用，流程约束可以不变。这样前期就能跑通核心用户体验，验证这个产品或方案是否可行，验证成本比先把整个程序全部做完要低得多。

Skills进阶

背景

背景依然非常重要。Skills 的模板中需要描述何时使用这个 Skill，但是如果要做这个列表其实很难，总有你忘记的情况或者是漏掉的。而背景存在的意义，就是让 Agent 充分理解你的软件功能和边界，Agent 可以凭借自己的理解来决定是不是该调用这个 Skill。

实际写的时候，背景最好分三层，不要只写一段产品介绍：

领域概念：软件是干什么的、核心对象有哪些（镜头段落、时间轴、配色动效模块等）
工作流：一条完整业务从输入到导出要经过哪些阶段
举例：用具体数字走一遍（比如 10 个主画面、8～12 个 scene、15 分钟以内）

「使用时机」和背景是互补关系。背景负责帮 Agent 理解边界，使用时机负责给 Agent 一个明确的触发词列表：

## 使用时机

在以下情况使用此技能
- 如果用户要生成一个镜头段落
- 如果用户要对 MR 内的镜头段落做修改
- 如果用户要对 MR 内的配色动效做修改
- 如果用户要对 MR 内的模块做修改
- 如果用户要对 MR 做短片导出
- 如果用户要对 MR 做转场演算
- 如果用户要知道当前 MR 的时间轴情况
- 如果用户要做一个菜单动效方案
- 如果用户要做一条门店菜单屏短片
- 如果用户要做一条菜单动效编排方案

每个子域 Skill 还可以再写自己的使用时机。比如时间轴相关的操作，单独在 时间轴.md 里再列一遍「转场演算 / 导出 / 查询时间轴 / 镜头段落编排」，Agent 读到子文件时更容易精准定位。

Description

正文里的「使用时机」很重要，但 Agent 加载 Skill 之前先看的是 YAML frontmatter 里的 description。它会被注入系统提示，用来判断「要不要读这个 Skill」。

description 建议用第三人称，同时写清 WHAT（能干什么） 和 WHEN（什么场景），比正文里列触发词更早生效：

---
name: MenuReel
description: 用于 MenuReel 中进行连锁餐厅数字菜单动效短片编排相关的功能描述和调用
disable-model-invocation: false
---

disable-model-invocation 也要想清楚：false 表示 Agent 可以根据对话自动加载；true 表示只有用户点名时才加载。Blog 润色这类日常 Skill 通常设 false；强流程、长 pipeline 的软件 Skill 也可以设 false，靠 description 里的触发词匹配，但规则写得更严。

MenuReel 的子文件（素材.md、时间轴.md 等）各自也有独立的 name 和 description，相当于子 Skill。主 Skill 负责路由，子 Skill 负责专域细节，discovery 和加载都更精准。

多文件拆分

上一篇的 Blog 润色 Skill，一个 SKILL.md 就够了。软件类 Skill 很快会膨胀，全部堆在一个文件里，Agent 既难检索，也容易漏规则。

MenuReel 实际拆成了这样：

SKILL.md              → 总入口：背景、状态机、P0 规则、开工门禁
├── 素材.md
├── 镜头段落.md
├── 时间轴.md
├── 配色动效模块.md
└── 接口协议.md       → 统一协议层：命名、回包、错误码、全量接口定义

主 Skill 只保留全局规则和路由，具体接口细节放到子文件里，用「功能细节参考 xxx.md」跳转。这和 Cursor / Anthropic 推荐的 progressive disclosure 思路一致：先给 Agent 看目录和约束，需要时再读细节，避免一次把几千行规则全塞进 context。

状态机 / pipeline

之前设计的流程，都是人工写的 1.2.3.4，但是实际上 Agent 执行时，还是有概率出现跳过流程或者不按你写的走。这种情况下就需要明确的状态机来规范 Agent 的执行流程。

### 状态机（必须）

`draft -> initialized -> assets_ready -> shot_ready -> timeline_ready -> computed_pass1 -> palette_ready -> computed_pass2 -> exported`

光写一条状态链还不够，每个接口还要绑定 next_state 和前置条件。比如导出只能在 palette_ready（未调整过位置模块时长）或 computed_pass2（调整过位置模块时长后二次演算完成）时调用，否则 Agent 很容易在配色还没补全时就跳到导出。

状态流转，也需要明确定义。复杂接口不能只写输入输出，要把后续必须执行的子步骤写清楚：

#### `mr.timeline.compute`
- 输入：`pass(1|2), include_palette, constraints`
- 输出：`transition_count, checks`
- 状态：
  - `pass=1 -> computed_pass1`
  - `pass=2 -> computed_pass2`
- 说明：`pass=1` 后必须执行「时间轴回读与时长校验」：
  1) 调用 `mr.timeline.query` 获取过渡模块真实时长（默认 3s 仅作为预估）；
  2) 演算成功后位置重排由程序自动完成，Agent 不再调用 `mr.timeline.move_module` 做常规重排；
  3) 再次调用 `mr.timeline.query` 校验总时长与模块连续性；
  4) 若总时长小于目标 `duration_sec`，按「静态段优先 + 按比例分配」计算增量，并调用 `mr.shot.update_duration` 扩充画面镜头段落时长（仅主画面 / 开场 / 收尾）；
  5) 若步骤 4) 发生了任一位置镜头段落时长调整，则配色补全后必须执行 `mr.timeline.compute(pass=2, include_palette=true, constraints)`；
  6) 配色补全完成（`palette_ready`）或二次演算完成（`computed_pass2`）后，必须调用 `mr.timeline.query` 输出全量模块位置信息（按 `start_sec` 升序）；
  7) 位置清单展示格式固定为 Markdown 表格（`顺序 | 模块ID | 类型 | 开始(s) | 时长(s) | 结束(s)`），并在表格后输出 `总时长`、`过渡总时长`、`主画面总时长`。

pipeline 约束，调用的流程或者是某些地方必须要执行些什么，都需要有约束的描述：

### 对话打印格式（必须）

```text
[PRINT-意图] <本次调用的中文意图>
[PRINT-调用] mr.<interface_name>(<key_params>)
```

### 最小调用模板（每一步强制复用）

```text
[PRINT-意图] <中文意图>
[PRINT-调用] mr.<interface_name>(<key_params>)
[CALL] mr.<interface_name>
Mock Response: {"code":0,"message":"success","data":{},"next_state":"<state>"}
```

### 全量执行要求（必须）

- 当 `scene_count=N` 时，必须完整输出 N 次创意调用、N 次线稿调用、N 次镜头段落调用、N 次时间轴编排调用。
- 配色动效模块同理，目标模块每一条配色创建都必须单独输出调用与回包。
- 任何一步若未输出，视为「流程未执行到位」，必须补齐后才能进入下一阶段。

规则分级 P0 / P1

规则一多，Agent 容易「全读一遍、全当建议」。MenuReel 在 接口协议.md 里给规则打了 P0 / P1 标签，让 Agent 知道哪些违反就必须停：

级别	含义	示例
P0	违反即停止，不得继续后续调用	状态机跳步、批量创建、省略中间流程、输出格式不符模板
P1	重要但次于 P0，多用于错误码分类	`1001` 参数缺失、`2001` 演算失败

写法上，全局规范和调用前置规则标 P0，错误码定义标 P1。Agent 看到 P0 就知道「这条不能商量」，比平铺十几条「必须」有效得多。

模拟调用协议

「模拟调用协议」，具体规则如下。除了上面的打印格式和全量执行要求，P0 级规则还包括：

必须按状态机顺序调用，不得跳步
缺参或状态不合法时，返回错误码并停止后续调用
禁止批量创建：每次调用仅允许创建一个对象（1 个素材 / 1 个镜头段落 / 1 个模块）
2D 镜头段落有两条合法路径：创意图 -> 线稿图 -> 镜头段落，或 线稿图 -> 镜头段落
模拟调用时不得省略中间流程；禁止用「同样方式继续」「scene_01~12」「…」「等」来合并步骤
不符合「最小调用模板」的输出视为无效调用，必须立即按模板重发

失败路径也要写清楚，不然 Agent 跳步了你拦不住：

### 错误码

- 1001 参数缺失
- 1002 状态不允许
- 1003 约束冲突（元素数量 / 画布安全区）
- 2001 转场演算失败
- 3001 导出失败
- 4001 禁止批量创建
- 4002 镜头段落前置步骤缺失
- 4003 必填用户输入未完成
- 4004 中间流程被省略
- 4005 缺少创意编排确认

Agent 合并步骤时应返回 4004，没做创意确认就调 init_project 应返回 4005，然后停止，不能继续往下走。

无效输出强制重发

P0 规则里有一条：不符合「最小调用模板」的输出视为无效调用，必须立即按模板重发。光写规则不够，最好给 Agent 一个固定的纠错输出格式：

[PRINT-意图] 检测到输出格式不符合模板，当前调用无效，立即按标准模板重发
[PRINT-调用] mr.<interface_name>(...) -> INVALID_FORMAT

然后紧接一条符合模板的标准调用。这样 Agent 自己漏了 [CALL] 或 Mock Response 时，有明确的自我纠正路径，而不是悄悄往下跳步。

开工门禁

软件类 Skill 和 Blog 润色 Skill 最大的区别之一：Agent 要先当产品经理收需求，再当工程师调接口。MenuReel 里设了两道门禁。

第一道：用户必填输入

参数未齐全时，不允许执行 mr.init_project 及后续接口：

project_name
element_count
theme

缺参时优先用 AskQuestion 做结构化选择框交互，禁止丢一段「请按模板填写」的文本让用户自己填。新方案必须视为新会话，不得默认复用上一轮的参数；只有用户明确说「沿用上次参数」时才允许复用。

AskQuestion 降级链

结构化交互也会失败，Skill 里要写降级策略，而不是假设 AskQuestion 永远可用：

默认单轮全量提问，一次收集全部缺失字段
调用失败或未返回有效选择 → 重试 1 次
全量提问连续失败 → 降级为分批提问（每批 3～4 个字段）
仍失败 → 降级为文本追问该字段，写回后直接继续，不再二次确认
全部字段收集完成后直接进入下一阶段，不做参数总览的第二轮确认

隐式上下文

project_name、theme、scene_count、duration_sec、画布约束等，在开工时收集一次即可，之后作为当前会话的隐式上下文全程携带，不需要每个接口都重复传参，也不出现在接口的入参/出参定义里。

Agent 只需要维护两件事：当前隐式上下文（项目参数）和当前 state（状态机位置）。接口调用只传该步真正需要的参数（如 shot_id、asset_id），Skill 写清楚这一点，Agent 才不会每个 mr.shot.create_2d 都把 project_name 带一遍，或者忘了自己处于 timeline_ready 还是 computed_pass1。

第二道：创意编排确认

在执行 mr.init_project 前，必须先给出完整的「创意与画面编排说明」，至少包含：

总体创意主题与叙事结构
每个画面的名称与内容说明（与 scene_count 一致）
每个画面的时长分配
每个画面的配色动效设计（出现 / 展示 / 消失）
开场与收尾的设计说明

输出后必须向用户请求确认；用户明确确认前，不允许进入接口调用阶段。这一步是为了防止 Agent 凭猜测直接开干，后面改起来成本很高。

接口定义

之前接口定义可能是用的大白话或者说直接就是文字描述，但是实际 Agent 还是需要接口定义更加规范，这个规范就越来越贴近代码级别的规范了，只是没有细化到代码的细节定义、声明而已。

实际维护了两套文档，用途不同：

子域文件（如 镜头段落.md）：给 Agent 看操作步骤，「列出参数 → 输出完成」
协议层（接口协议.md）：给 Agent 看状态约束、前置条件、错误码、全量接口清单

verbose 写法示例：

#### 创建镜头段落-2D

镜头段落的数据来源是 2D 素材（svg、png），通过此接口完成素材到镜头段落的转化

输入素材 ID（asset_id），输出镜头段落 ID 和基本信息（时长，画布占位）

接口名：`mr.shot.create_2d`

输入参数：`asset_id(来自 mr.asset.create_2d_line), element_count, layout(width_px,height_px), duration_sec`

输出结构：`code, message, data(shot_id), next_state`

- 1.列出用户的输入参数
- 2.输出「用户调用创建镜头段落-2D，完成」

compact 写法示例：

### 3) 镜头段落

#### `mr.shot.create_intro`
- 输入：`rows, cols, spacing_px, intro_offset_px, duration_sec`
- 输出：`shot_id`

#### `mr.shot.create_outro`
- 输入：`rows, cols, spacing_px, duration_sec, same_as_intro`
- 输出：`shot_id`

#### `mr.shot.create_2d`
- 输入：`asset_id(必须来自 create_2d_line), element_count, layout, duration_sec`
- 输出：`shot_id`

#### `mr.shot.create_3d`
- 输入：`asset_id, element_count, layout, duration_sec`
- 输出：`shot_id`

#### `mr.shot.query`
- 输入：`shot_id`
- 输出：`shot_meta`

- 状态：存在开场 + 收尾 + 至少 1 个主画面镜头段落后可进入 `shot_ready`

完整协议还覆盖素材（5 个接口）、时间轴（6 个）、配色动效（2 个）、项目 init / export 等，镜头段落只是其中一个域。接口命名统一 mr.<domain>.<action>，回包统一 code / message / data / next_state。

Mock 换真接口

真接口上线后只换 [CALL] 背后的实现。具体可以分三层，Skill 里的流程约束一层都不动：

Skill（状态机 + P0 规则 + 错误码 + 反模式）
  ↓ 约束 Agent 怎么一步步走
[CALL] mr.xxx
  ↓ 当前是 Mock Response；上线后替换为：
MCP tool / CLI 脚本 / HTTP 调用

这和前一篇里说的 MCP vs Skills 定位一致：MCP 管真接口，Skill 管流程和经验。Mock 阶段验证的是「Agent 会不会按你的 pipeline 走」；接上 MCP 或脚本后，验证的是「真程序能不能接住 Agent 的调用」。状态机、打印模板、全量执行要求、错误码都可以原样保留。

Skill 迭代试跑

Skill 迭代试跑具体可以当成一套固定动作：

准备 3～5 条代表性话术：完整做一条短片、只改配色、重新做一条、缺参开工、中途改需求等
跑对话，记录 Agent 在哪犯规：跳步、合并步骤、跳过创意确认、口头说「已创建 10 个」而不输出调用
对症补 Skill：缺 P0 规则补 P0，缺错误码补错误码，缺反模式补反模式
真接口上线后，用同一批话术回归：只换 [CALL]，看流程约束是否仍然有效

MenuReel 实际跑下来，这套 Skill 一天内就能跑通主流程，真接口落地后几乎不用再改 Skill 正文，说明迭代试跑比先把程序全做完再对接 Agent 省得多。

反模式

写软件 Skill 时，下面几类 Agent 常见偷懒行为，建议在 Skill 里明确禁止：

批量创建：一次调用创建多个素材或镜头段落
合并步骤：用「其余画面同理」代替逐次调用
跳过确认：没做创意编排说明就直接 init_project
手动重排演算结果：演算完成后 Agent 自己调 move_module 改位置
改过渡模块时长：过渡时长以 query 结果为准，不允许 Agent 自行调整
复用旧参数：用户说「再做一条短片」时，直接沿用上一轮 project 参数

Summary

给软件写 Skills，和给 Blog 润色写 Skills，复杂度不在同一个量级。简单 Skill 一个文件、几段 Prompt 就够；软件 Skill 需要背景分层、frontmatter description、多文件拆分、P0/P1 规则分级、状态机、模拟调用协议、开工门禁、隐式上下文、错误码和迭代试跑，才能把 Agent 的行为约束在可预期的 pipeline 里。

核心思路可以概括成几句：

description 和背景补触发词的盲区
P0/P1 分级 + 状态机防跳步
模板、错误码和 INVALID_FORMAT 防省略
隐式上下文 + AskQuestion 降级保证交互可靠
接口定义趋近代码规范
Mock 试跑验证流程，MCP/脚本替换 [CALL] 接上真程序

程序接口还没全部 ready 时，先用 Mock 协议把 Agent 的执行方式固定下来，等真接口上线后再替换 [CALL] 背后的实现，Skill 本身的流程约束可以不变。

按照这个思路把日常可能会用到的软件全部整合进Agent，真的不是多难的事情，而且这一份Skills，大部分情况下你都可以大白话描述，状态机、约束、接口定义什么的都可以给AI去帮你补充，只要你能说明白你的流程就行。

实际把这一套流程完整跑通，一天都用不了，而且后面实际落地以后 Skills 基本没怎么修改过，验证得非常充分了。不过有一点要注意，Agent 的模型能力会影响 Skills 的发挥，如果是小模型或者一些比较弱的模型，理解能力堪忧，就算有上面的重重保障、防呆，还是会被跳流程或者胡言乱语，所以需要目前市面上常用的大模型才行。

Quote

Cursor

Blog增加搜索功能

Thu, 04 Jun 2026 00:00:00 +0000

Foreword

博客文章越来越多，靠标签和翻页找东西越来越费劲。站点是 Jekyll 静态部署在 VPS 上的，不想为了搜索再挂一个 Elasticsearch 或者 Meilisearch，所以目标是：构建时生成索引，线上纯静态文件，浏览器里完成检索。

试了一圈以后，最终用的是 Pagefind + 自建的子串索引 双轨方案。这篇文章记录选型过程、当前实现，以及和其他方案的对比，方便以后自己维护或者换方案时有个参照。

Pagefind

https://pagefind.app/

Pagefind 是 MIT 协议的开源静态站搜索库，和 Algolia DocSearch 那种「云端 API」不同，它完全跑在访客浏览器里：

构建阶段：jekyll build 产出 HTML 后，执行 npx pagefind，扫描带 data-pagefind-body 的正文区域，按语言规则分词，生成倒排索引（.pf_index、.pf_meta、.pf_fragment 等），和站点一起部署。
使用阶段：页面加载 pagefind.js + WASM，用户输入查询词后同样在客户端分词，在索引里匹配、排序，再拉摘要片段显示。

可以粗浅地理解成：离线建好「词 → 出现在哪些页面」的表，上线后只在浏览器里查这张表。它保证的是正文进了索引、能全站检索，但检索单位是 token（词），不是「任意连续汉字串」

这点和后面中文踩坑直接相关，说白了就是所谓的分词对于中文的适配度低，很多中文词分词不正确导致没有被索引

本站 pagefind.yml 里配置了 force_language: zh-cn，npm 依赖目前是 pagefind ^1.5.2（1.5 起对 CJK 有加强，仍解决不了所有短语场景）。

Pagefind +自建索引

整体是双轨：Pagefind 负责广搜和 UI；search-index 负责中文 连续子串 的精确匹配。导航栏「搜索」+ Ctrl+K 打开同一个 Pagefind 弹窗，精确匹配结果插在 Pagefind 结果列表上方。

flowchart TB
  subgraph build_step ["构建：VPS deploy 或本地 build.sh"]
    J["Jekyll build"]
    HTML["_site HTML"]
    PF["npx pagefind"]
    IDX["插件 search_index_generator"]
    PFD["输出 pagefind 目录"]
    SH["输出 search-index 分片"]
    J --> HTML
    HTML --> PF
    HTML --> IDX
    PF --> PFD
    IDX --> SH
  end
  subgraph browser_step ["浏览器"]
    UI["pagefind-modal 弹窗"]
    PFJS["Pagefind WASM 检索"]
    WK["search-cjk-worker"]
    EXACT["精确匹配列表"]
    PFRES["Pagefind 结果列表"]
    UI --> PFJS
    UI --> WK
    SH --> WK
    WK --> EXACT
    PFJS --> PFRES
  end

构建链路

VPS 上 deploy.sh 在 git pull 后有更新时执行：

jekyll build --destination /usr/share/nginx/html
npx pagefind --site /usr/share/nginx/html
search-index 由 Jekyll 插件 _plugins/search_index_generator.rb 在 post_write 钩子里生成（Node 脚本 scripts/build-search-index.mjs 仅作备用）

本地开发可用 ./build.sh，步骤相同。

Pagefind改动

正文容器：_layouts/post.html 里 post-container 带 data-pagefind-body；标题、副标题、标签用 data-pagefind-meta。
忽略区域：导航、页脚、data-pagefind-ignore（见 pagefind.yml 的 exclude_selectors）。
前端：footer.html 引入 pagefind-component-ui.js、pagefind-modal；nav.html 搜索按钮打开弹窗。

Pagefind 适合：英文单词、长文全文、模糊相关内容；摘要高亮、子结果锚点也是它自带的。

自建索引改动

中文博文里大量 造词、地名、产品名（如「限宽墩」「奥美品牌定位」），读者往往是「记得这几个字连在一起」来搜。Pagefind 会把查询拆成更小的 token，容易出现：

搜「限宽墩」命中别的文章里的「限制」「路宽」「墩子」
真正写有「限宽墩」的《天津自驾游》反而直接搜不到了

因此在 Pagefind 之外增加 子串索引：

项目	说明
路径	`/search-index/manifest.json` + `/search-index/2015.json` … `2026.json`
单条格式	`[url, title, searchableText]`，无重复字段
可搜内容	标题、副标题、正文内所有 `h1–h6` 标题文字、正文纯文本前 800 字
匹配方式	`indexOf(查询词)`，必须连续子串命中
运行时	打开搜索框后加载 manifest，Worker 并行拉各年分片，在后台线程检索，不堵 UI
展示	弹窗内「精确匹配（N）」列表，样式对齐 Pagefind 卡片

根路径 /search-index.json 只剩几十字节的指针：{"v":2,"manifest":"/search-index/manifest.json"}。全部分片合计约 880KB（单文件 JSON 塞全文，体积到 9.7MB，首屏解析卡死，就放弃了）。

Service Worker

博客开了 PWA，js/sw.js 对 /pagefind/、/search-index/、search-cjk-*.js 走 network-only，避免旧索引被 SW 缓存导致「新文章搜不到」。缓存命名空间已迭代到 main-v5-，改版后需要用户注销一次 SW 或硬刷新。

踩过的坑

现象	原因	处理
新文章搜不到	SW 缓存了 `/pagefind/`	SW 对 pagefind 路径不缓存
`search-index.json` 404	仅本地 build 未部署插件产物	Jekyll 插件随 build 生成；deploy 检查 manifest
搜「品牌定位」有数量无列表	过滤逻辑藏光 Pagefind 结果 + 注入被重绘清掉	独立 `pf-cjk-results` 容器，去掉误杀过滤
一直「正在搜索」	单文件 9.7MB 主线程 `JSON.parse`	按年分片 + 仅打开搜索时加载 + Worker
「限宽墩」精确匹配没有天津篇	词在文末 `####`，800 字截断未覆盖	索引增加全文标题层级文字

典型验证词：品牌定位（标题命中）、限宽墩（小节标题 + 正文）、奥美品牌定位（标题子串）。

子串包含 vs 分词

	子串包含（search-index）	分词（Pagefind / jieba）
规则	连续字符序列出现即命中	先切词，再按词匹配
适合	限宽墩、品牌定位、Su7 Ultra	营销、自驾、STM32 等主题词
误匹配	少（要求连续）	中文易拆字沾边
新造词	不依赖词典	词典没有则易切错

改善 Pagefind 中文 不等于只改 jieba：还要改查询侧分词、匹配是否要求连续、标题权重等；对个人博客维护一个 Rust/WASM fork 不划算。更务实的做法是：Pagefind 继续广搜，子串索引补短语

方案对比

方案	类型	中文短语	集成成本	运维	备注
Pagefind + search-index（当前）	静态双轨	子串轨准确	中（已落地）	仅 nginx 静态	UI 现成，构建多一步
仅 Pagefind	静态	弱	低	静态	英文体验好，中文词组不稳
FlexSearch / MiniSearch	纯前端	可配 CJK encoder 或构建期分词	中高（自写 UI）	静态	索引逻辑自控，无官方弹窗
Lunr + 中文扩展	构建期索引	依赖分词 trimmer	中高	静态	Hexo/Hugo 常见，Jekyll 需自己接
hexo-tokenize-search 思路	构建 search.json	构建期 tokenize	中	静态	和 search-index 类似，需移植
Meilisearch / Typesense	独立服务	好	高	需 Docker/进程	体验最好，违背「纯静态」初衷
Algolia DocSearch	SaaS	好	低（若符合条件）	云端	开源文档站为主，个人博客未必合适
Fork Pagefind 改中文	改 Rust/WASM	可做成子串或更好分词	很高	静态	MIT 允许，长期合并上游成本高

没有找到一个「魔改 Pagefind 中文版」的成熟 Fork；官方在 Issue 里讨论 CJK 子串（如 #987），上游演进可跟，不必私有维护一整条搜索引擎分支。

Summary

博客搜索采用 Pagefind（分词全文 + 弹窗 UI）+ 按年分片的子串索引（中文短语精确匹配）。构建时 Jekyll 与 Pagefind CLI 各生成一套静态数据；使用时同一弹窗先展示精确匹配，再展示 Pagefind 结果。中文技术文里造词、固定词组多，子串包含比单纯优化 jieba 更贴需求；Pagefind 仍保留，负责英文、长文深处和模糊检索。若以后文章量或需求变化，可以考虑只强化子串轨（甚至去掉 Pagefind），或给上游贡献 CJK 子串模式，但现阶段双轨是性价比最高的平衡点。

由于有AI，所以Pagefind fork以后修改的方式也试过了，本地测试走通了，拿我整个Blog的词都做过测试，分词效果比官方好多了，也就不需要什么search-index了，但是上线的时候发现有问题。Blog都是在老VPS上了，CentOS，Pagefind编译是在另外一个VPS上，编译后的结果呢，CentOS跑不了，老VPS呢内存太小，跑不了Pagefind编译，好家伙给我死锁了。

要动老VPS的环境，相关要重新部署或者修改的内容有点太多了，于是就放弃了，AI修改Pagefind还是比较简单的，下次VPS换了再换成私有Pagefind也可以。

Quote

cursor

本文80%由AI生产

测试管理工具

Wed, 03 Jun 2026 00:00:00 +0000

Foreword

测试用例的管理，测试用例一定是关联到某一个需求的，基于这个需求产生的测试用例

但是呢，需求是一期一期做的，可能一个需求里混了一些不相干或者零碎的其他功能内容在里面

如果每一期的用例混在一起，对应的测试用例集就混了一些不同方向或者归属的用例

测试人员的期望是测试用例后期可以按照功能或者什么标签之类的进行划分，需要的时候回归测试某些功能的用例，然后根据情况有一部分还要转化为自动化用例，作为保底

实际测试用例随着功能变更，过往的测试用例也需要变更

测试用例同时还要满足评审的需求，有评审的流程和结果

自动化用例和普通的手工用例可能还会混在一起，这里就需要再进一步进行标签上的区分

测试用例测试完成以后，还需要对应的报告输出。这些是基础测试的管理工具的需求，市面上是否有工具可以满足或者其他某些工具可以稍微改造一下来满足。

Allure TestOps

https://qameta.io/

TestOps，界面比较简单，价格比较美丽，39刀/月/人，稍微有点贵的离谱了，体验sandbox里只有guest身份，很多东西不能操作，局限性太大了，还是要试用一下。

试用必须企业邮箱

左侧导航栏，中间是所有用例，右侧是测试用例的详细信息，具体怎么操作，预期结果是什么，如果点每个标签就可以自动进行同标签筛选

导航内的功能就有测试计划，测试每一轮的结果，

TestOps的试用稍微有点问题，激活以后无法进入激活的测试空间，DNS无法解析，这个是限制了中国？

国内默认不给解析，需要额外翻墙处理

看样子，TestOps是每个用户给一个独立的实例去跑，这个实例启动要一会，所以账号激活以后还进不去，要等一会

TestRail

TestRail的注册激活就人性化一些，看起来也是要实例启动以后才能进入，但是他有一个界面给你展示，TestOps就缺少了这些

TestRail暂时没有对国内做限制，可以直接访问

TestRail可以创建demo项目，类似样板项目，快速感知TestRail能做的事情

一目了然，不过TestRail看起来页面还是比较老的技术，不是响应式的，每次全页面都重新加载，有点老气了。

这种重新加载用起来感觉好累，卡卡的感觉

用例一多，加载起来确实很慢，转圈都转半天

整体管理逻辑和TestOps差不多，就是难用了一些

基本标签，是否可以自动化，分配给谁做，这些都有，用例是基于Section和Case进行管理的

TestRun里面是每个用例可以手动切换状态，每次切换都需要commit一下，说明，确实有点太重了，一天测几百个用例，这里来回点还是挺麻烦的

Xray

https://www.getxray.app/test-management

Xray是基于Jira家的组件，这里就不测了，要绑定Jira

MeterSphere

https://metersphere.io/

https://github.com/metersphere/metersphere

不愧是国内的，符合中国体制的宝宝，demo演示直接给账号密码，本身有社区版，开源，功能看起来支持得也还行

导入用例，有现成模板，用AI转化一下就行

然后用例内可以关联需求，不过这个也是一个用例操作一下，有点傻了，缺少批量的那种关联，需求也只能关联一个链接，没有具体内容的展示

用例执行，也是类似TestRail，每次执行都有一个commit

MeterSphere也有一个评审的流程，可以大家过这个评审

但是关于怎么触发自动化测试，MeterSphere界面上至少是一点都没有，看不出来怎么触发。官方说法是可以通过jenkins插件触发

在MeterSphere中，可通过Jenkins插件实现特定条件或操作触发自动化测试，具体方式如下：

Jenkins集成触发

安装MeterSphere Jenkins插件后，在Jenkins任务中添加MeterSphere构建环节。

配置MeterSphere平台认证信息，选择指定项目下的接口测试用例。

通过Jenkins的定时任务、代码提交触发（如GitLab Webhook）或手动执行等方式启动测试。

关键组件协作

Task Runner：统一调度接口测试任务。

Result Hub：处理测试执行结果。

Kafka：接收测试结果数据供后续分析。

扩展触发方式

通过Chrome插件录制Web请求生成JMeter脚本并导入MeterSphere，结合CI/CD流程触发。

使用IDEA插件同步接口定义，基于代码变更自动触发测试。

更多细节可参考架构图：组件说明

用例上没有很明显的自动化标签，估计要实测看结果了

Qase

https://www.qase.io/

弱智东西，非企业邮箱输入会提示错误，但是就是不告诉你错误原因，企业邮箱立马就成功

界面也还行，比较简单的，也算现代化的

Qase的测试内容的描述更符合我预期一些，自动化的标签是有的，不过似乎没有和需求挂钩的地方

AgileTest

https://agiletest.app/

AgileTest的这个价格稍微有点低，一个人1.5刀，这不是把其他人架起来烤嘛，不过Agile 也是ATLASSIAN公司的，需要配合Jira一起用，这个有点麻烦，我没有Jira，只能放弃了

Testiny

https://app.testiny.io/

Testiny，没想到有国外的软件，中文适配的还行

也有类似的问题，缺少自动化的标签，自定义标签没看出来哪里能设置，感觉他是靠树形结构去做归类的

Testiny的自动化也是通过接口来实现的，不过这里是把自动化的结果报告进行了同步收集，似乎并不能直接在Testiny这里直接触发自动化运行。

aqua

https://aqua-cloud.io/

aqua的价格有点逆天，产品89欧/人，测试管理89欧/人，测试19欧/人，注册有点麻烦要国外手机验证，虽然我有，但是我懒得注册了

testmo

https://www.testmo.com/

testmo感觉还行，据说被testrail背后的公司收购了，然后一片唱衰，都说会被搞垮。

看了一下基础用例管理方式依然是通过文件夹的形式进行分类的

QAlity Plus

https://soldevelo.com/products/test-management-for-jira/

只适配Jira

Excel

传统测试工具，Excel其实是能满足上面所有内容的，无论是和需求关联、分组、打标签、评审、自动化，它都可以，只是有点没系统，所有都是人工约定的，没有很强的模板约束，其数据本身的历史追溯有点困难，文件存储本身也需要解决。

其他

其他类文本工具，比如notion、wolai、plane、各种智能表格等等，进行一定的改造也能满足测试的需求，就是有点不专业，很多流畅性的东西需要外部处理

其他一体的平台也包含一部分测试平台的内容，只不过这里我们已经有了其他内容的补充，暂时不需要那么重的一个平台，单纯能管好测试用例就够了，其他Devops有其他工具做了。

Summary

目前看下来MeterSphere可能是其中较为好用的，至于迁移成本，现在有AI干活的情况下，只需要你能把以前的数据导出来，那么这个成本就非常低，给好上下文背景，测试平台的接口或者模板格式给好，让AI把用例转移一下形式，其实非常容易，很简单就能迁移到新平台上

测试管理平台还看到了一些别人的需求，这里还包含了普通的小白测试人员，对应的任务分配，时间管理等等也会被集成到这个管理平台上，相当于可以量化考核每个测试人员的工作量

同时还有一个缺陷管理，测试出现的问题集中到缺陷中，但是大部分这个都做得比较弱，因为这个问题一般都需要挂到对应的任务管理系统中，比如Jira、Plane里面，这样好安排工作一些。

这个兄弟说得挺好的，测试是否需要管理工具，是否需要这么多细节流程来确认测试工作人员是否工作到位了，这个东西和产品的质量，成本需要找到一个平衡点，大多数公司都没有找到。挺无奈的，研发、测试一环扣着一环，都是对上一步结果的再次验证和纠正，只要有人在这里，只要你不是三体人，那表达一定会有出入，最终的路径一定要经过二次甚至三次验证才能出结果，这就无形中抬高了很多成本了。

还有一种方式这个测试体系或者架构从一开始就是自己构建的，那么在这种情况下，结合一下AI，把excel表进行数据库化，然后加上一个前端作为展示和修改界面，其实就可以满足大多数测试的需求了，这个架构也不是很难，现在AI做其实很简单了。这种方式定制化程度很高，基本啥需求都可以自己搞定。

Quote

google

https://www.reddit.com/r/QualityAssurance/comments/197qvo7/thoughts_on_best_test_case_management_tool/?show=original

奥美品牌定位有感

Thu, 21 May 2026 00:00:00 +0000

Foreword

之前参与了一下奥美的品牌定位会议，感觉还挺有意思的，至少在做事的方法论上还是可以的，记录一下

Ogilvy

https://www.ogilvy.com/cn/

奥美（Ogilvy）是全球知名的营销传播集团，1948 年由“广告教父”大卫·奥格威（David Ogilvy）在纽约创立。它以品牌战略、创意广告、公关与数字营销见长，长期服务跨国企业与本土头部品牌。如今奥美隶属于 WPP，属于典型的“全球方法论 + 本地执行”型咨询与传播公司。

负责给我们上课的同时也是为华为品牌战略服务的负责人

第一课

第一课，说明品牌是什么，干什么，弄清品牌的定义。本质上就是在做小培训，先教会非品牌出身的人，让他们明白这是什么，而不要乱带节奏，不要自说自话。

区分清楚老板、公司和公司品牌这几个概念，往往很多时候，都被混为一个，老板会觉得公司就是代表自己，很多品牌决策都过于主观，而没有遵守公司品牌、公司人格这个独立的东西。

说是进了这门不区分上下级，但是出门都要工作、生活的，有些东西被刻进骨子里了，不是说可以就行的。

第一课主要就是摸底，确认好公司内大家的诉求是什么，品牌的一些共性或者基础内容都有什么，然后说明要得到什么结论。

比如，品牌短句，长句，愿景，使命，性格，logo，这几个最最基础的东西，而这些内容奥美本身已经有一个初步的定义了，毕竟是做过很多项目的，大概理解还是有的，只是对于领域内的一些细节可能了解不是很多。

之后就是奥美，给出他们的一些想法，供我们参考。

做的几个活动，主要靠策划人引导，然后将公司的人分几个组，不同组进行发表，虽然说这不是辩论会，不是比赛，但是人嘛，总是希望发表以后得到认同或者说同化他人。这个过程中，其实也是各种人被洗脑，被忽悠的一个过程，简短的几个概念词被反复提起、拆解、强调，不懂的人会被快速同化。

无论是组内讨论还是组外讨论，每个组都安排了一个奥美的助手，并且全程录音，组内讨论后续也会被他们拿去分析，助手也会在组内引导大家的思考逻辑，纠正一些跑偏的讨论方向。

总体来说：

求同存异，求最大公约数
结果可能是少数服从多数
活动过程中允许你发表意见，说服他人，说白了会闹的孩子有奶吃，表现力强的人往往会影响其周边的人，进而成为一个共同体，导致组与组之间稍微有点点对立

从培训形式来说挺好的，至少只要你主动，参与感是有的，但是如果你全程冷漠，那么这个事情就真的跟你没关系了

第二课

第一课的输出，奥美需要分析一段时间，然后第二课就是基于之前的结果进行总结，再给出几个选项，让所有人选。算是缩小了品牌定义的范围，在这里进行少数服从多数的投票了。

这里其实还有一个隐含标准：不是只看谁说得好，而是看哪个表达更容易被用户理解、更容易在市场传播中复用。

从结果来说，大家基本趋同了，总结出来的品牌短语、长句，基本一致了，只是略有偏差，这些后面定死就没啥问题了。

还有一些细节，可以看，奥美在做分组的时候，是有特意安排过的，来平衡某种角色或者背景的人过于集中的问题

第二课和第一课的分组又不相同，再次进行各人的意见融合

不过对于企业人格，品质等方面的用语，明显意见差异特别大，最终得到的结论和我自己的也有差距，这里过于文学性，咬文嚼字了，带来的区别有点太小了。

方法论反思

奥美这套流程在“统一认知、快速收敛”上非常有效，尤其适合内部观点分散的团队。但它也有天然边界：当目标是找一个更激进、更差异化的品牌方向时，多数共识机制往往会把表达磨平，最后得到一个“大家都不反对，但也不够锋利”的答案。

另外，活动结果会受到现场话语权影响。表达能力强的人更容易带节奏，谨慎或内向的人观点容易被淹没。为了避免这个问题，最好在讨论前加入匿名写卡、独立评分，再做集中讨论，这样结论会更接近真实共识，而不是现场情绪。

最后，品牌定位的完成不等于品牌建设的完成。真正难的是把定位落实到产品叙事、销售话术、市场传播和组织行为里，并且在 3-6 个月里用线索质量、转化效率、用户心智反馈去验证。

落地清单

如果只输出了一套品牌话术，而没有配套动作，最后大概率会变成 PPT 工程。至少要做下面几件事：

产品侧：把品牌主张映射到产品功能命名、版本发布叙事、官网卖点排序
销售侧：统一首句自我介绍（结合我自己碰到的销售，这个是有的）、行业方案开场、异议处理话术
市场侧：统一公众号、官网、短视频、展会物料的表达口径
组织侧：把品牌关键词写进招聘 JD、绩效沟通和新人培训材料

这几项如果没有同步，品牌定位再好，传到市场端也会失真。

常见失败信号

复盘下来，品牌定位项目最常见的失败，不是方向错，而是执行断层：

内部会议里都认同，外部客户却听不懂
对外说的是一套，对内做的是另一套
每个部门都说“理解了”，但实际物料和话术各说各话
三个月后没人再提这件事，品牌项目自然失效

所以品牌定位不是“一次性决策”，更像是“持续校准机制”。如果没有持续复盘和纠偏，前面的共识很快就会被日常业务冲散。

Summary

有些时候公司是技术主导的，导致很多东西过于偏向技术化了，而没有考虑到当前市场、普通人对于这些词汇或者概念的接受程度，这种情况就需要品牌引导，拉回来一些

有时候公司领导过于固执，或者这个体系过于僵化，没有人可以成为破局者，此时就需要外部的人介入，从他们第三方的视角来看这些事情，从而推动变革，这也是为什么一些顾问公司能存在的价值吧

Gitlab制品库实践记录

Wed, 20 May 2026 00:00:00 +0000

Foreword

之前理解的制品库就是把CI的中间过程进行存储，虽然也包含了最终发布的部分，但是总觉得没啥大用，就没在意。后续发现其实从工程到生产环节有很多东西都需要进行交付，之前只关注了最核心的产品内容，周边一些零碎的东西，其实也需要被统一管理。而这个时候如果有很多个仓库需要一起进行打包、管理，这个就非常复杂了，而借助CI和制品库就可以通过规则把这部分内容统一管理起来，发布时进行大包发布即可，这些零碎的小工程也没有强耦合，可以随意发挥

背景

生产时需要管理的不只是单个 .bin或者.exe，而是一套 已验证可一起上线 的产品组合：

硬件烧录固件（SOC、MCU、FPGA等）
测试治具固件
其它治具与工具（RFID、MAC、IP、参数等配置工具）

各组件由不同负责人维护、版本节奏不同，因此适合 GitLab 多仓库独立开发，再通过 manufacturing-kits + manifest 在发布时打成单一制造包，并自动生成与发布说明。

目标：组件独立迭代方式

sequenceDiagram
  participant Dev as 组件负责人
  participant Repo as 组件 GitLab 仓库
  participant REL as Release 页面

  Dev->>Repo: MR 合并 / 本地构建
  Dev->>Repo: 打 tag，创建 Release
  Repo->>REL: 上传附件 + 填写 Release Notes

理清思路：

Gitlab 社区版没有制品库或者制品这个概念，但是我们可以通过Gitlab仓库本身的功能，建立一个制品仓库，把制品的manifest文件和对应的CI动作都集成在这个仓库里，需要发版的时候只需要触发这个仓库进行CI即可。

而对于各个仓库来说，完全是不知道这个制品仓库的，从而实现解耦。

生产物料清单

首先需要确认实际生产需要的物料清单，并以此为准进行模板制作和规则约束

分类	组件 ID（建议）	负责人	是否必选
MCU烧录	`fc-mcu` 主控	A	必选
SOC烧录	`fc-soc` 核心	B	可选
测试治具	`fixture-mcu` MCU治具	C	必选
测试治具	`fixture-soc` SOC治具	A	必选
其它治具/配件	`rfid-fixture` RFID工具	B	可选
	`mac-fixture` MAC工具	C	可选
	`ip-fixture` IP工具	A	可选

命名规则：{产品线}-{YY.M.D}，例如 P1-26.5.20 → 对应 Git tag / Release 名。

一般来说生产是按批或者订单进行的，只涉及到生产改动时这个进行改动即可

仓库结构

往往一个仓库可能要应对多种产线的情况，此时仓库保持独立，而不是submodule就很关键

flowchart TB
  subgraph component_repos [各组件独立 GitLab 项目]
    R1["fc-MCU-firmware"]
    R2["fc-SOC-firmware"]
    Rn["... 每个组件一个或一类一个"]
  end

  subgraph meta [发布与制造]
    MR["manufacturing-kits<br/>产品线 P1 / P2 ..."]
    DOC["自动生成 P1-26.5.20.md<br/>即治具更新内容"]
  end

  subgraph registry [制品]
    PKG["各组件 Release 附件"]
  end

  subgraph line [产线]
    OFF["脱机固件升级设备 / 工位"]
    LOG["生产追溯 DB 或 MES"]
  end

  R1 -->|打 tag + Release 附件| PKG
  R2 --> PKG
  MR -->|读 manifest,从 Release API 拉附件| PKG
  MR -->|打 Kit Release| PKG
  PKG --> OFF
  OFF --> LOG

可以看到这种情况下组合打包，本质上需要一个manifest，这个里面规定了打包的内容

仓库划分

建议仓库划分方式，但不是完全说死的

类型	做法
产品固件	一类一仓，如 `P1/fc-mcu-firmware`、`P1/fc-soc-firmware`
治具固件	可合并为 `P1/fixture-firmware`（多 bin）或按治具拆分
工具	`P1/ip-burn-tool` 等独立仓（版本节奏与固件不同）
制造包	一个产品线一个 meta 仓：`P1/manufacturing-kits`（无业务代码，只有 manifest + CI，也可以多产线一个仓库）
文档	治具更新 Markdown 不手写维护，由 CI 从 manifest + 各组件 Release description 生成

「如有」组件：manifest 里 required: false，未参与本次 Kit 则整段在生成文档里标 「本次未更新 / 沿用上一 Kit」。

manifest模板

在 manufacturing-kits 仓库中，每个 Kit 一个 YAML，与模板一一对应：

# kits/P1-26.5.20.yaml
kit_id: P1-26.5.20
product_line: P1
release_date: 2026-05-20
previous_kit: P1-26.4.12        # 用于「相对上一正式版变更」
validated_by: [A, B]            # 集成测试通过签字（审批人）
offline_upgrader_min: "2.1.0"   # 升级设备最低版本（若有）

components:
  fc-mcu:
    release_tag: v123.123          # 对应组件仓库 Releases 的 tag
    artifact: fc-mcu-v123.123.bin  # Release 附件名（需含后缀）
    sha256: "..."
    required: true

  fc-soc:
    release_tag: v45.6
    artifact: fc-soc-v45.6.bin
    required: false                # 本次未改则可 omit 或 inherit_from: P1-26.4.12

  fixture-mcu:
    release_tag: v2.0.1
    artifact: fixture-mcu-v2.0.1.bin
    required: true
  # ... 其余字段与模板章节同名

规则：

必选组件：Kit 发布前必须在 manifest 里 显式 release_tag + artifact，且组件仓库 Release 已存在。
可选组件：未列则 CI 从 previous_kit 继承上一版引用（文档里写清楚「沿用 P1-26.4.12 之 fc-soc v45.6」）。
各组件仓库由 owner 在 Release 页发布附件并填写说明；制品库 CI 不编译，只从 Release 拉文件。

示例

模板字段	来源
文件名 `P1-26.5.20`	`kit_id`
版本：v123.123	各组件 `release_tag`
固件文件：a.bin	`artifact`（Release 附件名，需与页面上名称一致）
更新内容 1/2/3	组件 Release `description`；或 manifest 手写 changelog
@负责人	manifest `owner` + GitLab CODEOWNERS
「如有」	`required: false` + 继承策略

发布物目录示例（CI 打 zip）：

P1-26.5.20/
├── MANIFEST.yaml              # 机器读
├── 治具更新内容-P1-26.5.20.md  # 人类读，版式同现模板
├── CHECKSUMS.sha256
├── firmware/
│   ├── fc-mcu-v123.123.bin
│   ├── fc-soc-v45.6.bin
│   └── ...
├── fixture/
│   └── ...
└── tools/
    └── ip-burn-tool-...

产线 / 升级设备：只部署 kit_id 对应 zip（或从内网按manifest 拉取）。

各仓库的动作：

步骤	动作	角色
1	在 `manufacturing-kits` 新建 `kits/P1-26.5.20.yaml`，填写各组件 `release_tag` 与 `artifact`	发布负责人（如A牵头）
2	开 MR → 触发集成流水线：校验 Release 存在、拉取附件（若有自动化测试可在此跑）	CI + 各 owner 审批
3	MR 合并 → tag `P1-26.5.20`	发布负责人
4	CI：生成 Markdown、打 zip、创建制品库自身 Release	自动
5	通知生产：仅允许 `P1-26.5.20`；脱机设备刷入该包	生产 / 工艺
6	每台（或每批）记录：`SN ↔ kit_id ↔ 时间 ↔ 工位`	生产 / MES

manufacturing-kits 仓库目录

manufacturing-kits/
├── README.md
├── catalog/
│   ├── components.yaml
├── kits/
│   ├── P1-26.4.12.yaml
│   └── P1-26.5.20.yaml
├── schema/
│   └── kit.schema.json          # 校验 manifest 字段齐全
├── templates/
│   └── 治具更新内容.md.j2       # Jinja2，版式与现模板一致
├── ci/
│   ├── collect-artifacts.sh
│   ├── generate-release-doc.py
│   └── validate-kit.sh
└── .gitlab-ci.yml

.gitlab-ci.yml 阶段示意：

validate：schema + 检查各组件 Release 是否存在
collect：按 manifest 从各组件 Release API 下载附件
document：渲染 更新内容-P1-26.5.20.md（可合并 Release description）
package：zip + sha256
release：制品库打 Kit 的 GitLab Release

注意manufacturing-kits + manifest

不是 GitLab 自带的产品功能，需要自建一个 GitLab 仓库 + 写一点 CI/脚本；GitLab 提供的是「存清单、跑流水线、存制品、发 Release、做审批」这些积木。

catalog

manufacturing-kits的仓库里不仅仅要有各个kit的配置文件，由于各种代码仓库本质上是公用的，所以需要有一个目录层作为更上级，描述各个仓库的路径或者包名什么的，作为公共使用。

# 组件 ID → GitLab 项目（仓库路径在 catalog，Kit 里只写 release_tag）
fc-mcu:
  project_path: code/Firmware/fc-mcu
  project_id: 101              # 可选，API 用 id 更稳
  artifact_type: bin
  default_artifact: fc-mcu.bin

fc-soc:
  project_path: code/Firmware/fc-soc
  project_id: 102
  default_artifact: fc-soc.bin

ip-fixture:
  project_path: code/Facility/onion_ip
  project_id: 205
  default_artifact: onion_ip.exe
  branch_is_product_line: true # Release tag 建议形如 X1/v1.0.0

fixture-mcu:
  project_path: code/Facility/fixture-mcu
  project_id: 210
  default_artifact: fixture-mcu.bin

对应的CI程序就需要这么执行

读 Kit → 拿 fc-mcu 的 release_tag
     → 查 catalog 得 project_path=code/Firmware/fc-mcu
     → GET /projects/.../releases/{tag} → 按 artifact 名下载 assets.links

制品模式

有了上面内容以后，就可以给Cursor自动去完成制品库的文件编码了，但是第一次制品的流程，我发现有点问题。

AI默认你的制品库的CI流程是从各个仓库拉代码，然后编译，产生目标文件，然后再打包。其实在生产这里稍微有点点不同，这里各个仓库本身可能不完善（涉及到n多个不同环境），甚至CI流程都不太行，所以这里优先直接拿release页面的文件，而不是把打包编译的流程全跑一遍。

对应的release页面这里就需要对应的owner去手动发布，并且编辑更新的内容

基于这个问题，又让AI改了一下制品库的模式

实际测试

Runner

如果要用Gitlab的CI流水线，那么要先配置好 Runner。可以用 VPS，也可以在内网 Windows 机器上装（例如 shell executor + Git Bash），在 GitLab 项目里注册并授权即可

runner可以通过官网下载，然后配置

https://docs.gitlab.com/runner/install/

.\gitlab-runner.exe register  --url https://gitlab.xxxx.com  --token glrt-xxxx3d32-6LxN9

runner有一个小细节要注意一下，经常容易卡住流水线，无法正常跑下去

你的 CI 里三个 job 都没有 tags:，属于 untagged job。

若 Runner 配置了标签（例如 docker、build），且未勾选「运行未打标签的作业 / Run untagged jobs」，该 Runner 不会接这些 job，界面就会显示「没有可用 Runner」。

建议最好不要在windows上跑runner，很多问题，cmd在最新的runner上不能用，powershell也会有一堆问题（最好用pwsh），建议换成git bash来跑

Job运行时需要访问到各种项目的页面，对应的这些项目就得授权过去，可以在CI/CD的Job token中进行设置

Release

调试了老半天，流程总是走不通，不是这有问题，就是那有问题。

沙雕AI打zip包，他打个tar包改名叫zip，后续流程中验证zip包，怎么验都错，但是我自己用zip解压可以正常打开，查半天

后续仔细看了一下发现是Gitlab的一点小问题，AI自己根本搞不明白为什么

这个Release中软件包是只有名称，没有后缀的

而CI文件里写的是需要后缀来识别的，那么一旦子仓库的发布内容不包含这个后缀，那么对应的制品库就无法正常跑下去，这个破问题弄半天，AI自己把自己绕进去了。

除了这个问题，Gitlab还有一点不如Github，发布页面不能直接引用仓库内的文件，不能直接添加资源，不能直接上传，这就导致你要把发布页面包含仓库内的东西就必须走Gitlab CI或者是手写一个脚本利用API来上传文件，然后这里还有坑点。这个你后上传的文件，是有权限的，走CI的那个流水线似乎没权限，访问不到这个链接，而要解决这个问题就还得给CI的脚本配上 owner 的 token，一环扣一环。

实际上如果走Gitlab内部的上传库，runner是可以正常访问的，生成物也是能正常访问的
Gitlab的Release只愿意做一个纯链接页面，而没有一个实体存储的对象

子库CI不编译

现在最好的解决办法就是子仓库用Gitlab的CI，但是不编译，仅仅做打包和发布，编译的内容在仓库内建立一个Release文件夹，把每次发布的文件存储到这个里面，由Gitlab CI进行打包和发布即可

制品库环节就和上面说的流程一样走即可

Summary

所以如果要走Gitlab，那么就得全流程最好都走，想中间偷个懒或者不走Gitlab要解决的问题就有点多了。

Quote

Cursor

天津自驾游

Tue, 19 May 2026 00:00:00 +0000

Foreword

周末小米举办了天津V1国际赛车场的活动，五一前就已经报名了1节练习+1天竞速，然而天公不作美，很多安排也不如预期，就改做自驾了。

天津

V1国际赛车场

V1赛车场这次开放的是最长路段，4.2km，接近街道的赛道也给开放了，但是本质上挺危险的，V1赛车场虽然是F2级别，但是这个缓冲区的级别和凯泽差不多，没有波波池的缓冲，都是类似水泥地或者马路的缓冲区，减速可能不理想

先在模拟器连了一周，不四轮出白只能开到2分01，更快可能就有点作弊了，之前以为只是模拟器没有建模波波池，实际去了真场地，真的没有波波池，可以走偷鸡线路。

去天津之前已经基本确定了，练习日可以玩，竞速日会下雨，打算把竞速日退掉，没想到说了半天，不给退。最蠢的是官方举办的活动，竟然赛道地图没上线，要玩家现场自己画，真尼玛离谱。你练习日不行就算了，怎么竞速日也不行呢，包场2天，一个地图画不出来，这还是提前了半个多月预告的活动，真不知道在玩啥。

练习日

只报了最后一节练习，没想到那么多人，先是教练带着走线走了2圈，然后上去以后画赛道，画3圈，然后才能正式跑，这会已经掉了一些电了，人又多，根本跑不开

跑到2分10秒以内应该很轻松，刹车点都比较早，而且一圈遇到三四个车都是常态。练习一节，1小时，这个时长也很抽象，中间去充电，回来又满是人，我直接连续跑了，最后剩下百分之十几的电下场了，缺电以后后面怎么开都是2分12秒或者2分11秒，很难比刚开始快了

竞速日

不出所料，竞速日全天下雨，我的水平和开法，根本扛不住一点spin，天津这个地方spin我大概率会上墙，所以果断选择放弃，自驾一下市区更有意思

自驾

天津的这几个景区基本都在一块，走路大概就是一两公里就能到，反而是开车堵得要死，都是落在老城区里，都是单行道，车又多，还下雨

静园

静园是溥仪幻想复辟时期所住的地方，很洋气，也很符合当时他有点崇洋和后续希望借助外部力量进行复辟的思想境界。静园能看的内容比较少，现在基本都是后来仿制的，中间溥仪离开以后这个地方几经周转，曾经破落得不成样子，溥仪死后才被重视重新修缮。

张园

张园可得好好夸夸，算是我逛这些小景点里做得最好的了。门票都是一样的30，但是体验大有不同。

张园每天固定时间都有表演，每场间隔大概一个半小时，实际演出接近一个小时，纯免费。表演的内容也不是尬演，而是带入了当时的场景，同时也有点类似景点讲解的导游。

表演融入了天津的一些艺术形式，现场互动做得很好，再加上现场来的基本都是偏向大学生、高中生，年轻的一代，确实很有活力，对比我等和一些老年人过来，都有点感叹。这种形式的思想、历史教育，确实非常不错，不是空喊口号，而是带你亲临当时的环境。

小屋子里人也不多，大概八九十人，口号喊得激昂。现场的人也能参与表演，情侣甚至都给你准备了结婚仪式，虽然很短，但是他有，最后还有大合照，加群，抽奖，奖品是另外一个景点的门票，说是这个景点是他们相同团队做的，实际很拉跨，后面会提到。

不仅仅是有表演，本身展馆里就设置了一个剧本杀的谜题，而各种线索就隐藏在环境中，各种历史讲解中，你想解开谜题就要去仔细看历史，了解历史，我在现场看基本只要是年轻一些的面孔，都是人手一份，每个人都在解谜

同时展馆的后面也专门布置了一个剧本杀的场所，至于何时开就不知道了。

原汇丰银行旧址

原汇丰银行旧址，就是张园同团队的另一个历史馆。打车的时候司机就说不知道这个地方存在，距离张园没多远，2km不到，我就感觉有点不对劲，可能这里内容不行。票价也不贵，30，等到演出开始了才进去。然后就是一个女演员，一个人表演完所有内容，非常尴尬，特别是开场的舞蹈都是演员和这种衣架做的假人互相表演，后续的内容也基本就是舞女的独白，没有观众的互动，各个场景其实做得也很浮夸，很塑料质感。

虽然是同团队，只能说这里踩坑了，怪不得游客这么少，没人来，类似张园其他项目这里直接就是没有。

五号院相声

去得比较晚，已经开场了好一会才进去，错过了一点。不过现场人很少，基本可以随便坐，也没本地人，都是游客过来听的。

一共三个节目，第一个单口快板、第二个男女对口相声、第三个也是个对口相声。现场互动还是蛮多的，既有传统相声的冒犯，也有一些脱口秀的内容。

看着演员都挺老成的，实际他们自己说才刚20岁，完全想不到，都是十来岁就出来练相声，到这里表演了的。现场有个女生笑得贼搞笑，导致演员台上都被她感染了，不过演员的现挂能力还是有点问题，稍微容易被尬住，而且有些要控制自己的地方没好好控制，相对的相声老梗、老段子还是有挺多的，新内容比较少吧，而且节奏或者包袱抖来抖去，老是那几种冒犯的形式，对比脱口秀确实有点老东西的感觉了。

总体上还是值得一去的，他们也顺便嘲讽了一下周边的几个景点，比如瓷房子、xx故居，让游客别上当。

现场点了个瓷缸喝大碗茶，有点那个意思。

瓷房子

没进去，只在外面拍了一下照片，大概就是各种瓷器来组成房子的各种部分，只能说博眼球，而且这个是现代后做的，本身不是真的老东西。

张爱玲故居

这个故居有点纯蹭的意思，是小时候的房子了，现在主要是咖啡馆，需要消费入场，不去也罢。

其他

天津之眼

路过两遍，但是周六晚上竟然不亮灯，不知道为啥，反正没拍到

观澜角/东堤公园

海边公园，看着建设得挺好的，人少，风景又好，可惜最后没时间去。

限宽墩

返程时由于大雨，高德导航又给导到村路上去了，然后走了10公里的村路，每两公里就有一个限宽墩，之前只在网上看到过，没实际试过，车感还行，车身极限是197cm，算上后视镜大概是217-220cm左右，基本都是直接进去就过了，一点调整都不用，看了一下后视镜，极限1cm左右。

有个板车就搞笑了，进来了，但是出不去，出去的墩小了一点，过不去，卡门口了

吃

狗不理包子，津门张记包子铺(江都路店)，看似包子很瓷实，其实皮很薄，味道说不上好吃难吃，就是正常包子，纯手工，不是预制的

天津中栗华蒸饼店，这店有点拉，虽然很多人排队，但是这个蒸饼吧，真的有点馒头夹馅的意思，味道和预制品差不多，没必要买

刨冰，王中王（荔枝刨冰/红豆芒果炼乳/三黑等），没机会，没吃到

普通吃菜的，看到了很多推荐这几家的

砂锅李（李家大排/芙蓉鲜贝/虾茸草菇白菜）
聚发号（辣子鸡丁/盐爆肚丝/素烧茄子/扒牛肉条）
肥猫烤翅（经典甜辣烤翅/疙瘩汤/醋椒豆腐）

Summary

时间还是略短，还有很多东西没时间体验

北京自驾游

Mon, 11 May 2026 00:00:00 +0000

Foreword

车在北京，顺便周边自驾转转，看看北方发展成什么样了。从北京去了保定，打算从西南边逛起，再回北京见同学，接着往西北边逛了一圈，然后直奔秦皇岛。

保定

保定虽然就在北京旁边，自古以来也是守卫京畿的重地，主要景点基本都在中心城区。但保定给我的感觉和去粤西、揭阳那会儿差不多：有点破，有点穷。

古莲花池

没啥看头：不是莲花开花的季节，园子又小，又是北方路子，确实没法跟南方那种细腻的园林比。

直隶总督署

保定要拱卫京师，权力最大的衙门就在莲花池对面：直隶总督署。清代不少头面人物在这儿办过公，曾国藩、李鸿章、袁世凯之类，依然没啥看头。

白洋淀

白洋淀去得太晚，只剩游船，别的景区进不去了，倒也够用。我坐的是木游船，满员6人，人力摇橹——没听错，人力——正常一圈大概两小时，离谱。后来船工集体摸鱼，换快艇给拽回去了。景色倒是没啥特别的，就是芦苇荡；芦苇也不够高，荷花也还没到开的时节，反倒是柳絮重灾区，张嘴就能吃饱。

芦苇密的地方确实跟课本写的一样，船钻进去就找不着了。这片红色景区不少，我都没去。游船泊到一座孤岛，全员上岸，船工歇口气；岛很小，就几个卖货的，随后又被直接拉回码头。

雄安新区

雄安之前看过不少介绍片，以为建设得多唬人呢，实际一看也就那样：路也就三车道，楼也不高，估计限高了。生活配套更少，只有几个偏一点的地方人稍微多一点。路边要么还是林子，要么正在施工，总体挺空。

悦容公园

悦容公园别当真以为是给老百姓的——连个像样的停车场都没有，能是给百姓用的吗？说白了就是旁边那块是给领导配的景，站在高处往下看用的。园里设施也锈迹斑斑，挺破败。

北京

之前没想到北京周边能这么穷、这么奇葩：很多路都是单行道，路旁大白杨大柳树，清一色砖房和老房子。路况也一般，跟广东村里那种路没法比，进城才好一点。

园博园

园博园很大，我只顺路扫一眼，基本没人，里头不少地方在维修，五一搭的临时设施也在拆。

本以为园内电瓶车能开着兜一圈，快速扫完，结果被坑惨：自带导航解说，嗓门巨大还关不掉，一路社死。避障估计也有毛病，走一路报一路障碍，龟速，还不如人慢跑。无语。

价格更离谱：起步30块半小时，之后一分钟一块钱，咋不去抢。园里还有多人自行车，看别人骑也一样遭罪。

园博园太老了，2013年建的，这么多年维护跟不上，不少园子、建筑都斑驳了。22年起改免费市民公园。

首钢遗址

之前以为首钢赛道在北京，没想到在秦皇岛；北京这边好歹还有首钢遗址公园。停车场刚好在冷却塔底下，头一回挨这么近的冷却塔，确实凉快。

永定河畔

首钢旁边就是永定河，传说中的永定河畔，现在是一个大公园

石景山

巧了，石景山也在同一个地方，石景山很矮，不费力就登顶了，山上就一点古建筑，也没啥特殊的了

妙峰山

北京比较出名的跑山地界是妙峰山，这次也去遛了一圈；还有个红井路，人称北京秋名山，这次没时间没去。

妙峰山前半段还能跑起来，后半段尽是短促回头弯，不敢猛踩油门。

山顶就那么回事，一块平台，能看出有人在这儿玩过漂移，人很少。也俯瞰不了北京，看的是反方向。

西二旗

中国互联网除了深圳南山、上海，剩下大头基本在北京西二旗。刚好傍晚过去，人爆炸多。这几天在北京开车没觉得电车有多少，一到这儿密度陡增，路边人也密。

同学顺带领着转了圈小米西二旗总部，挺好：食堂便宜得离谱，比深圳城中村还便宜。最近挺火的小米价值观冰淇淋好像卖光了，没吃上。

鸟巢

鸟巢能买票进，还能登顶；对面水立方、奥林匹克塔、玲珑塔、中国考古博物馆一串都能看见。

一晃鸟巢都快二十年了，内里不少细节也显旧了。

长城

八达岭长城头一回去，晚上就住山脚下，条件很挫，只能叫宾馆；好处是第二天出门就是索道，上去省一大截腿力，再爬一小段就到北城墙顶，大部分城墙都能俯瞰。

长城确实有巨物感：在这种山脊上砌砖墙，工程量难以想象；更关键的是长度吓人，长得远处城墙我都拍不清。

明十三陵

明十三陵有神路、昭陵、定陵、长陵四处联票；我实际走了神路、昭陵、定陵，长陵放弃。

神路值得去一趟，算十三陵门面，巨物感拉满，气派，但实质内容不多，只能说后人维护得太整齐。

昭陵人最少，我去的时候现场就我一个，随便溜达。昭陵基本上把陵墓该有的建筑凑齐了。

定陵卖点是地宫，地上部分跟昭陵一套模板。地宫要下八九层楼的样子，里面没啥看头，一股橡胶地垫味，不值得专程来。

长陵跟昭陵类似，多一个大殿，遂跳过。

十三陵本是一大片皇家陵区，如今被拆成几块卖票；总览图上看仍然气派，龙头龙尾龙山那一套，皇家叙事拉满。

小米汽车超级工厂

顺路参观了一下小米汽车超级工厂，确实很牛逼，至少给看的压铸车间，人很少，91%的自动化率，车间内基本都是靠机械臂和AGV完成每一个工序，而且工厂并不仅仅是平面的，立体的也有用到，车间的转运都走在高处。参观的人一波接一波，各种政府或者机构的人都过来参观或者试乘。参观还是有点粗，讲解人员也只是背稿，实际东西并不是很理解，总体车间参观大概是30分钟左右，全流程45分钟，后面就是介绍一些大家都知道东西。

同时工厂的食堂也对外开放，这个食堂倒是和深圳的小米食堂差不多

巧了，之前没吃到的冰淇淋，这里有，但是服务人员还是有点偷懒，三个不一样价值观的饼干，她给一样的，被我说了，才给我其他的

秦皇岛

秦皇岛离北京大概三百公里，不到三小时能开到。

北戴河

「这么近那么美周末到河北」口号喊得响，北戴河真到了也就那样：典型小吃街，同一种小吃重复五六个摊位；傍晚海风老猛了，外套都扛不住。北戴河实际是戴河以北那片，主打避暑、度假、赶海、沙滩。

阿那亚

阿那亚，为了体现高端，很多东西都是独有的，比如园区内的导航、公交、充电、预约、支付等等都是阿那亚定制版的，所以需下阿那亚APP才能正常游览。

阿那亚分南北区，建议住南区：北区小，打卡点多数在南区；北区也相对穷一点，住户更集中在那边。两区隔着大马路，运营方默认你不靠腿，得坐穿梭巴。园区大，内部有摆渡车串大景点，但模式很呆——固定站点固定班次；其实车间隔短、车也多，若能招手停会好用得多。

进门或预约最简单的一招：订间青旅床位，人不去睡，办个入住拿个能预约的身份，景点就好约了；实测当天约也不难。

北岸悦本质是青旅，我图便宜订了大床房，结果踩雷：床头疑似漏电——手机充着电，一手拿机一手摸不锈钢床头，能感觉到微微发麻；放下手机又没了。插座嵌在床头板里，估计哪儿搭线了。洗手龙头也为造型牺牲好用度，难拧，还带着整根龙头一起转。

北区

阿那亚算是中高产的高级社区，食堂多，环境在线，但硬把常住居民和观光客搅在一锅。

社区本体观感干净：指示牌少，画面利落，代价是导航费劲——常住的人大概无所谓。

艺术类建筑偏清水混凝土、性冷淡风，裸面不少。

第九食堂早饭扫了一眼，消费不低，比深圳贵；游客价、业主价两套。保洁有 SOP，先喷后擦，不像别处一块油抹布糊弄。食堂几乎没「食堂味」，陈设讲究，自助收盘也不用分筷子，人性化到位。

宠物友好：场所外常有宠物笼暂存，有的还能牵进去，还在建宠物水上乐园，怪不得遛狗的来扎堆。

贩卖机基本平价，没搞景区翻倍那套。

小孩游乐设施多，抱娃来的自然也多。

北教堂不必专程去：人少，框景也没做出来，气质有点神神叨叨，摸不着头脑。

北区卡丁车纯子供向，没成人什么事；有的馆子干脆不开。服务人员密度极高，人力堆出来的基础体验——可想而知日常运营成本得多吓人。

业主区外观像美式、英式红砖公寓那路数：红砖饰面，外挂疏散梯，楼层不高；里头小别墅多是合墅，面积也不大。

店员、服务人员远看可能摸鱼刷手机，但你朝他们走过去，哪怕不说话，也会立刻收手机摆好姿态。当然也偶有装看不见的，那是极少数。

眼下算是阿那亚上升期，上述观感都写在脸上；哪天模式扛不住开始降本增效，服务质量大概率跟着下滑。这套打法至少暂时把房价抬起来了：秦皇岛这种度假地、偏远海边社区，单价两三万，大概是周边盘的四五倍。对比惠州各湾，早就跌穿底线，环境也折腾得不成样子。另一方面社区提供了大量基层岗位，服务人员配置偏冗余，培训和底子还行。

公寓物业费四块、别墅五块九，比深圳不少楼盘还贵；玩法跟惠州类似，买了交给物业代租吃租金。

孤独图书馆

孤独图书馆进门换鞋套，馆内禁拍，但扛不住带娃大军，哭闹不停，跟「图书馆的静」不沾边。

「孤独」更扯淡：淡季里头都接近坐满，外围还有一圈打卡的游客，谈何孤独。

所谓阅读，半数人在刷手机；书也随手堆着，网红属性大于藏书。

想人少可以午饭时段来。馆藏和空间都有限，不必专程来装文艺。

阿那亚礼堂

礼堂里同样禁喧哗、禁拍；座位紧俏，想坐第一排得等人走开。

礼堂框景在线：前方有人玩滑翔伞，海面渔船，岸边牵手的情侣自然嵌进画面。顶上十字架配着巴赫 BWV 548「楔子」前奏曲，神性比北礼堂足。

若有心仪式感十足，在这儿布景求婚一类也未尝不可。

礼堂外风大，一直有保洁盯着周边垃圾，维持「出片」体面。不止礼堂：路边杂物清洁工会顺手捡，社区整体干净，少见卫生死角；搬家、装修中场也能很快收拾，不会半天没人管。路面砖缝油渍之类也有专人抠。

其他

UCCA 沙丘美术馆、阿那亚艺术中心都转了转，略抽象。

还试了赛级无动力帆船：工作人员再三提示当天浪偏大可能全身湿透，仍上了船；结果只湿了一点。船速不慢，得顺着浪主动挪重心，有点意思。

晚上闲逛碰见只黄鼠狼，不怎么怕人。

Summary

北京城里局部很现代化，一出城往六环、保定、河北方向，建设段位明显掉档，跟广东村里不是一个量级。不过华北平原是真平，一望无际，开阔。

Su7 Ultra U南向北

Wed, 06 May 2026 00:00:00 +0000

Foreword

由于保时捷包场，珠海赛道没机会玩，五月前我基本没去过其他赛道。四月初得知五一有U南向北活动，三天连刷北京三个赛道，这种强度很少见，我当场就决定去。

U南向北

5月2日到5月4日，北京三天畅跑三个赛道（凯泽、新金港、老金港），一个赛道一天，费用3000，超值。唯一的问题就一个：怎么把车弄过去。

由于提前知道天津V1赛车场的活动也会在五月举办，所以这趟一次性就能解锁四个赛道，还是非常超值的。

运输

深圳到北京有两千一百多公里，一般就两个办法：自驾2100公里，或者板车托运。自驾根本没这个时间，而且五一前上高速绝对超级堵，所以只能板车托运。

这次大湾区从广深出发一共七辆车，但是其他小伙伴都特别焦虑，巴不得20号就把车发出去，四月十号都没到就联系了各种拖车、酒店、机票，真的有点过于离谱了。然而事情往往变动得更快，有人介绍了一个朋友的拖车公司，价格非常低（2000，普通大概是两千五六的样子），想着是认识的不会被坑，就同意了，24号收车，25号出发，估计28、29就到达了。然而一直到28号，拖车还没出发，负责拖车的朋友满口谎话，一直骗我们很快就走或者各种原因，等到29号单独联系司机才知道车不够，发不了要等。而其他小伙伴本身就是焦虑体质，完全不同意，立马着手备用方案，高价（3000）找了另一个公司的车，包车把我们七辆车拖走并且立即出发。

新拖车司机一路被红包打鸡血，红眼猛冲，五月一号一早就到了北京六环，然而此时我还没意识到发生了什么。

等我五月一号晚上过去拿车，才发现四个气门芯帽被薅走了，腰靠也丢了。其他小伙伴也都有不同程度的小伤，轮毂蹭伤最常见。从老拖车转到新拖车时虽然找人拍了视频，但没想到中间就这一两个小时的时间差，还是被人搞鬼了。

模拟器备赛

三个赛道都练了大概一个月，凯泽开到了52，新金港开到了1分05，老金港开到了1分10。这次练习用了和以前不一样的方法：以前练珠海都是强行记刹车点、记哪里拐、哪里该怎么走；这次直接盲开，全凭速度感觉去刹车和开油。最终抛掉行车线以后，我可以直接凭速度感处理刹车和转弯，不像以前错过一点就直接上墙。这样练下来，总算有了“随便开一个没开过的图也不至于失速上墙”的底气。以前是背板，现在相当于靠下意识处理，容错明显高了。

凯泽赛道

下赛道

凯泽算是比较多Ultra开过，也有Pro车手的开发和讲解，资料比较充足，走线看一看就学会了。

凯泽赛道只能算还行，赛道维护还是可以的，只是场地太小了，缓冲区也很小，稍不注意就是真的上墙了，轮胎缓冲区都很少。凯泽的充电桩只有2个能用，还是上古老桩，30kw，需要刷卡才能充电，我运气比较好在这里充上了。

还好当天实际事故比较少，只有一个人稍微撞了一点墙，惠玮哥刮到了轮胎墙，没有大事故。

实际当天去了以后就发现天气不太行，有点阴沉。我被分到了萌新组，最先上场，熟悉一下和模拟器接近的感觉后立马开始操作。虽然一圈只有六个人，但还是有人挡我，没办法全力push，最终只开到56秒就被催着下场，实际一共就开了七圈。下场以后连汗都没出。然而万万没想到这就是最后一次上场。后续没多久就开始下大雨，赛道全湿，根本没法全力开，而且半热熔轮胎暖不起来，上去开等于送死。

漂移

凯泽的P房是在赛道内圈的，同时漂移场地也在赛道内，也就是说租下凯泽的同时，这个漂移场其实也被租下来了，虽然说不给用，但是实际上你随便玩也没人管，毕竟五一了没人愿意来上班。

刚开始没下雨的时候，就有人直接拿半热熔轮胎开漂，烟超级大，但确实帅，我也坐上去体验了一把。

也有人把握不住，直接轮胎漂到钢丝断了还没发现。

等到中午以后通知下半场没了，直接散场。这时还在下雨，人也走得差不多了，我就喊蔡哥教我漂移，单独练了快一个小时，能漂大概3/4个圆，摸到了一点感觉。在水泥地上起漂对轮胎磨损很小，还不错。场地巨大，基本没有其他车跟我抢，我就一个人玩，真的爽到了。由于我的轮胎还要继续用，后面雨慢慢停了，地面也有点干了，就收了。

新金港赛道

下赛道

新金港也算是比较知名的赛道了，加上Ultra刚出的时候就被各种车手试车和卷圈速，参考视频很多，而且圈速都做到了比较极限。

但是新金港赛道也是比较难的，各种坡度，还有盲弯，都比较考验控车技巧。实际没去过新金港，以为周边是比较完备的，毕竟那么多人都在这里玩，实际一去才发现不是那么回事。新金港基本处于一个特别偏远、废弃的地方，周边路上车都很少了，金港赛道本身旁边不允许建筑，所以连P房都没有，而厕所等等建筑都是那种房车、拖车形式存在的，旁边还有一个漂移场地，但是这次真的没租漂移场地，而且当日也有别的漂移玩家在场上玩，同去的车都不能停漂移场地，现场四十多辆车都停不下，得侵占一半的道路。

新金港本身赛道日1200就可以玩一天，据说去玩的人其实很少，一天可能就十几个人，基本上只要你上场就不会有人影响你，相当于包场。而如果想单买一节，得充值9999，才能按照一节一节的方式去玩。

当看到这个云的时候，不好的预感又来了，果然在我刷完以后没多久，突然就暴雨了，我趁机离开去充电了。第一次只刷到了1分12，没想到最后也没能突破这个圈速，阵雨来得快去得也快，一中午加上车上去扫水基本就把场地晒干了。

当天后续又刷了2节，但是次次都被挡。最后一节摄影师还把运动相机架在我车里了，估计他也没想到，一整圈几乎全是我在吐槽。好几次超车都差点怼到对方车屁股。实际如果我一个人刷，大概能开到1分10；每次被挡，基本都要慢1.x秒，后面就完全不行了。

在金港也试了试所谓的240神教，我只能说我是菜鸡，开不了一点。240刚上去，暖胎圈，假弯过完，回头弯刚往外出，给油我就Spin了，立马意识到是240导致的车尾灵活。于是乎后面开始小心翼翼地开，飞行圈开始，T1转过T2，给油，立马Spin，直接就冲向小山坡了，还好小坡很缓，只是吃点草而已，倒是掀起一阵灰尘，场控对讲机立马问是否有事，答无事，Spin而已。

这一节开到一半我就下场了，240过于灵活，我目前水平完全控制不住，模拟器里也没有相关调节。250的开法下，电控会帮你控制车身姿态，在有可能Spin的情况下，它绝对不允许你强行开油。你只需要走好线、摸好刹车点，能循迹就循迹，其他时间无脑给油就行，车自己会判断能不能给油。所以新手开240绝对不行，250会更保险；240很容易失控甩出去上墙，应该是进阶、有经验的驾驶者才能驾驭。

纽北Ultra专用车

当天贝勒爷也来了金港，刚巧落单被我抓到，收获合照一张。贝勒爷拿到了小米赞助的纽北专用车，日后车主去纽北都可以租借这台车下赛道，而不用官方测试车了。这台车还在现场收集我们车主的签名，后续会直接印在车尾翼上，我也签了，日后去纽北可以自己带自己飞了。

不得不说北京这个季节全是杨柳絮，飘得到处都是，得亏我提前带了个口罩，每天都是一身柳絮，手机屏幕、车窗缝隙都填满了

新金港由于难度比较大，凯泽没出现的车损在今天开始大批量出现了，当天就接近六七辆车出现车损，多次红旗，中止跑圈。

潜力车手

二三十人的住宿被群友的酒店包了，平常七八百的房间450给我们住，还是五一期间，超值，还给了海报、平面轮播，排面拉满。

当天的晚宴，我的圈速基本是萌新组最快，还拿到了潜力车手奖，奖品是个烧水壶。

老金港赛道

老金港，算是尘封已久的赛道了，根本没有Ultra刷过，市面上也没有资料可以参考。模拟器中开车好像还行，但是现实完全不是一回事。

老金港由于严重扰民，所以不允许油车下场，现在改名为新能源汽车赛车场了，只有一些学习赛照的才会在这里开车，平时完全不允许爱好者玩。实际赛道也很偏，周边环境也很小，好在是有一点配套设施的，P房还是有的，周边也有一些充电桩，就是路非常窄。

老金港由于缺少维护，赛道路面已经开裂，而且尘土很多，中间赛道巡游的时候明显能感觉到一直有很多细碎石子被粘起来。

第一节还是萌新组先出车，然而没想到赛道大师卡了个bug，导致我一节跑完没成绩，气死，抢占榜单第一也没戏了。

老金港我练的太多了，而且看了很多油车的开法，大概知道走线和注意点都是啥了，所以我心里很稳。但是没做功课的老司机们反而一个接一个翻车了。

当天上午，只要一节刚上去，没两分钟就必然出现事故，然后就下来等，一等就是四五十分钟，车损基本都是没办法移动那种级别的。就这样，大半天过去了，事故就有五六辆了，都是严重级别的。主办人终于忍不住了，狂喷现场的人，不遵守刹车点，过度push，特别是这个赛道情况明显不够好，而且缓冲区也非常小，很容易出事故。所有人被要求遵守刹车点，不然就终止活动，总算控制住了车损，然而当最后一节自由跑开始，又有人过度push，于是乎自然又有新的车损了。

第二节由于车损和部分人提前离场，萌新组第二组只有3辆车了，我总算是在没有人干扰的情况下刷了个爽的。

如果不是为了遵守刹车点，应该还能再快个1s多，不过就算了。这个场地确实有点危险，几次全力刹车都出现车门储物格里的东西跳出来，差点滚进刹车下面，还好被我踩住了，之前在珠海等地方就算270多刹车也不会出现物品飞出来的情况。

老金港由于换了新胎，抓地力明显比之前强了很多，G值都有1.4了，之前基本只有1.2左右。

Summary

总体来说，北京虽然有3个赛车场，但整体都不算理想：玩车氛围一般，参与人数偏少，车相关产业也比较落后。赛道里相对安全、配套完善的，目前也只有ZIC还可以。

U南向北这次活动，包了三个场，一个场按6w算，三个就是18w，而实际参与人数不到40。虽然拉了赞助，但看规模也不会太多，现场每天抽奖也只是小礼品。活动基本靠活跃群友无偿当志愿者，为爱发电。即使如此，这三天车损还是有十几辆，玩车风险系数确实高，普通人真不一定承受得起，特别是我认识的人里竟然有一半都车损了，确实惨。

而老昆（举办者）非要在赛车场用餐，餐标还是150，高得离谱，吃得巨差。在我看来还不如KFC、MDL，毕竟来跑赛道都比较纯粹，不是来吃喝的。第一天说烤羊腿，我没吃到，就一点自助；第二天总算吃到了，但是一个小瘦羊羔，五六十人分，能吃两片肉就不错了。第三天改烧烤，勉强凑活，舍得给肉了。建议以后取消这种用餐，毫无意义，赛后聚餐我可能还支持一下。

至于说好的每场颁奖，全都没了，活动流程也比较稀碎。除了第一天不迟到，后面天天都迟到。早到完全没意义，现场不给跑，一定要等到10点以后才开始，纯浪费时间。

后续需要重点练两件事：第一是救车，第二是关闭TC后的车辆控制。250再往上想提升，基本就得上240了，尾部姿态必须自己手动控。

AC录像转行车线与轨迹分析

Mon, 06 Apr 2026 00:00:00 +0000

Foreword

AC模拟器跑完的结果或者录像一直都有，但是缺少具体分析，也没找到类似的分析工具，不如自己写一个，刚好利用Cursor来完全做一个项目，我不写一行代码，仅仅做分析和指导方向，看看是否AI能实现我的全部要求，也能观察转成AI写代码时，我们的输入到底要做到什么程度，这个东西才足够好用或者能够工程化。

ACReplay2AILine

第一个需求其实是比较简单的，分析acreplay的文件格式，然后将其转变成ideal_line.ai的格式。

做之前第一步是询问AI，是否能实现将录像轨迹转成AI行车线，AI表示可以，并且给了几个方案，这里我审过以后，确认了基础实现的技术线路。

如果要我去找AC相关mod的制作信息并且了解清楚行车线和地图相关数据关系，还是比较耗时的，这里AI直接快速解决了问题。

核心结论就是只要非内置的行车线，就可以自行替代，而现在mod级别都不会内置行车线，恰恰方便了行车线的替换逻辑

当然也问了一下是否能根据车型、参数设置、赛道等等直接生成最优行车线，这里由于数据不全，所以AI回答也比较模糊，实际上AC有类似的Mod，但是那种行车线还是有延迟，而且不是很准。

接着就是先做一个最小的MVP，给出最核心的需求，先看一下是否能够实现。

根据回放1.388.acreplay文件转成zhuhai\data\ideal_line.ai格式，并替代

实际上给出这些命令，Cursor就已经完成了核心转换逻辑，实际测试确实替代了老的行车线，但是行车线还存在一些重复的部分并且刹车和油门的提示是错误的，但是轨迹基本都是正确的。

仔细回看，实际上给出来的命令并没有说明要做到刹车油门提示正确，只是说替换一个轨迹而已，所以AI也只是做了这么多内容

基于上面的逻辑，让AI补充提取逻辑

结合记录中的刹车和油门信号，补充到行车线中使用红色或者绿色提示

到这一步，AI直接理解了，并且刹车和油门提示正确了，但是还是有问题，acreplay中飞行圈有时候不一定是第一圈，存在半圈或者开场圈的一点点路径，AI把这部分内容也弄进去，导致一部分轨迹是错误的

根据记录的计时点开始和结束位置，提取轨迹路径

给完这个以后，AI自动理解了计时开始应该从0，结束的时间应该比较长，到这里提取出来的轨迹就是相对完美的了，实际生成的ideal_line.ai已经是我要的轨迹线了

给出更多acreplay文件进行测试，AI自动发现了飞行圈选择的问题，他自己增加了参数选择第n圈，但是实际上我们需要的是最快圈速的那一圈，这一步应该自动选择，而不是还要用户输入

自动识别acreplay中圈速最快的一圈作为提取的轨迹

到这里ACReplay2AILine就完全正常工作了

#Requires -Version 5.1
<#
.SYNOPSIS
  用 acrp 解析录像，将轨迹写入任意赛道的 data\ideal_line.ai（版本 7）。
.DESCRIPTION
  简易用法（acrp.exe 与脚本同目录为默认）:
    powershell -ExecutionPolicy Bypass -File .\BuildIdealLineFromReplay.ps1 `
      -Replay "C:\path\lap.acreplay" -TrackFolder "C:\...\content\tracks\zhuhai"

  多车手录像请指定 -DriverName。已导出 JSON 时可省略 -Replay，改用 -JsonPath。

  -TrackFolder: 赛道根目录（其下应有 data\ideal_line.ai，除非用 -IdealLinePath 覆盖）。
  -AcRpPath:  默认 = 脚本目录\acrp.exe

  路径可为绝对路径（如 C:\...\x.acreplay）、相对当前目录、或 ~ 开头（用户主目录）；首尾引号会自动去掉。

  轨迹与赛道：ideal_line 只按录像里的世界坐标 x/y/z 重采样，与「目标赛道文件夹」无自动校验，
  请自行保证录像对应该赛道。计时线模式：在起点 currentLap 等于 -Lap 的若干区间中，直接取弧长最长的一段作为一圈（出场短段自然被排除）。

  -Lap 对应录像 JSON 里的 currentLap 整型（通常第 1 圈=0，第 2 圈=1 …），不限于 0/1；第 N 圈飞行一般传 N-1。
  不确定时用 -ShowLapHints 列出每个计时区间起点的 currentLap。
#>
[CmdletBinding()]
param(
    [string]$Replay,
    [string]$TrackFolder,
    [string]$AcRpPath,
    [string]$DriverName,
    [string]$JsonPath,
    [string]$CsvPath,
    [string]$IdealLinePath,
    [int]$Lap = 0,
    [bool]$UseTimingLine = $true,
    [double]$MinSegmentMeters = 50.0,
    [double]$DedupePlanarMin = 0.05,
    [switch]$WhatIf,
    [switch]$KeepTempJson,
    [switch]$ShowLapHints
)

Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'

function Resolve-FsPath([string]$Path) {
    if ($null -eq $Path -or [string]::IsNullOrWhiteSpace($Path)) { return $Path }
    $p = $Path.Trim()
    while ($p.Length -ge 2 -and $p.StartsWith('"') -and $p.EndsWith('"')) {
        $p = $p.Substring(1, $p.Length - 2).Trim()
    }
    if ($p.StartsWith('~')) {
        $rest = $p.Substring(1).TrimStart('\', '/')
        $p = if ($rest) { Join-Path $HOME $rest } else { $HOME }
    }
    return [IO.Path]::GetFullPath($p)
}

function Show-Usage {
    Write-Host @"
用法:
  BuildIdealLineFromReplay.ps1 -Replay <录像.acreplay> -TrackFolder <赛道文件夹> [选项]

必填（二选一）:
  -Replay         Assetto Corsa 录像路径
  -TrackFolder     赛道根目录（内含 data\ideal_line.ai）

或已手动用 acrp 导出:
  -JsonPath / -CsvPath  与 -IdealLinePath（或 -TrackFolder）

常用选项:
  -DriverName      多车时指定车手名（传给 acrp --driver-name）
  -AcRpPath        默认: 脚本所在目录\acrp.exe
  -IdealLinePath   默认: <TrackFolder>\data\ideal_line.ai
  -Lap             与录像 currentLap 一致（第 2 圈多为 1，第 3 圈多为 2，依此类推）
  -ShowLapHints    只打印计时线分段与每段起点 currentLap，不写 ideal_line（仅需 JSON）
  -MinSegmentMeters  计时线模式下，若「该 Lap 最长区间」弧长仍小于此值(m)则放弃切段（防数据损坏），默认 50
  -UseTimingLine:`$false  关闭计时线截取
  -WhatIf          只预览不写文件

示例:
  powershell -ExecutionPolicy Bypass -File .\BuildIdealLineFromReplay.ps1 `
    -Replay ".\my.acreplay" -TrackFolder "..\zhuhai"
"@
}

$scriptDir = $null
if ($PSCommandPath) {
    $scriptDir = Split-Path -LiteralPath $PSCommandPath
} elseif ($PSScriptRoot) {
    $scriptDir = $PSScriptRoot
} else {
    try {
        $exePath = [System.Diagnostics.Process]::GetCurrentProcess().MainModule.FileName
        if ($exePath -and (Test-Path -LiteralPath $exePath)) {
            $scriptDir = Split-Path -LiteralPath $exePath
        }
    } catch { }
    if (-not $scriptDir) {
        $a0 = [Environment]::GetCommandLineArgs()[0]
        if ($a0 -and (Test-Path -LiteralPath $a0)) {
            $scriptDir = Split-Path -LiteralPath $a0
        } else {
            $scriptDir = (Get-Location).Path
        }
    }
}
if (-not $scriptDir) { throw 'Cannot resolve script directory (expected exe or .ps1 path).' }
if (-not $AcRpPath -or [string]::IsNullOrWhiteSpace($AcRpPath)) {
    $AcRpPath = Join-Path $scriptDir 'acrp.exe'
} else {
    $AcRpPath = Resolve-FsPath $AcRpPath
}

$useJson = $false
$tempWork = $null

if ($Replay) {
    if (-not $TrackFolder) { throw "使用 -Replay 时必须同时指定 -TrackFolder（赛道根目录）。" }
    if (-not (Test-Path -LiteralPath $AcRpPath)) {
        throw "找不到 acrp.exe: $AcRpPath （可设置 -AcRpPath，或把 acrp.exe 放在脚本同目录）"
    }
    $replayFull = Resolve-FsPath $Replay
    if (-not (Test-Path -LiteralPath $replayFull)) { throw "找不到录像: $replayFull" }

    $trackFull = Resolve-FsPath $TrackFolder
    if (-not (Test-Path -LiteralPath $trackFull -PathType Container)) {
        throw "赛道目录不存在: $trackFull"
    }
    if (-not $IdealLinePath) {
        # "指定在哪里就在哪里"：默认不再强制落到 data 子目录。
        $IdealLinePath = Resolve-FsPath (Join-Path $trackFull 'ideal_line.ai')
    } else {
        # 相对路径按当前工作目录解析，不再强制挂到 TrackFolder。
        $IdealLinePath = Resolve-FsPath $IdealLinePath
    }

    $tempWork = Join-Path ([IO.Path]::GetTempPath()) ('ac_ideal_' + [guid]::NewGuid().ToString('N'))
    New-Item -ItemType Directory -Path $tempWork -Force | Out-Null
    $outPrefix = Join-Path $tempWork 'acrp_out'

    $argList = New-Object System.Collections.Generic.List[string]
    [void]$argList.Add('-o')
    [void]$argList.Add($outPrefix)
    if ($DriverName) {
        [void]$argList.Add('--driver-name')
        [void]$argList.Add($DriverName)
    }
    [void]$argList.Add($replayFull)

    Write-Host "运行 acrp: $AcRpPath"
    $proc = Start-Process -FilePath $AcRpPath -ArgumentList $argList.ToArray() -Wait -PassThru -NoNewWindow
    if ($proc.ExitCode -ne 0) {
        if (-not $KeepTempJson) { Remove-Item -LiteralPath $tempWork -Recurse -Force -ErrorAction SilentlyContinue }
        throw "acrp.exe 退出码 $($proc.ExitCode)"
    }

    $jsonFiles = @(Get-ChildItem -LiteralPath $tempWork -Filter *.json -File | Sort-Object LastWriteTime -Descending)
    if ($jsonFiles.Count -eq 0) {
        if (-not $KeepTempJson) { Remove-Item -LiteralPath $tempWork -Recurse -Force -ErrorAction SilentlyContinue }
        throw "acrp 未在临时目录生成 JSON: $tempWork"
    }
    if ($jsonFiles.Count -gt 1 -and -not $DriverName) {
        if (-not $KeepTempJson) { Remove-Item -LiteralPath $tempWork -Recurse -Force -ErrorAction SilentlyContinue }
        throw "生成多个 JSON（多车？），请添加 -DriverName 指定车手。文件: $($jsonFiles.Name -join ', ')"
    }
    $JsonPath = $jsonFiles[0].FullName
    Write-Host "已解析: $JsonPath"
    $useJson = $true
} elseif ($JsonPath -or $CsvPath) {
    if ($JsonPath -and $CsvPath) { throw "请只指定 -JsonPath 或 -CsvPath 其中之一。" }
    if ($JsonPath) {
        $JsonPath = Resolve-FsPath $JsonPath
        if (-not (Test-Path -LiteralPath $JsonPath)) { throw "找不到 JSON: $JsonPath" }
        $useJson = $true
    } else {
        $CsvPath = Resolve-FsPath $CsvPath
        if (-not (Test-Path -LiteralPath $CsvPath)) { throw "找不到 CSV: $CsvPath" }
    }
    if (-not $IdealLinePath) {
        if (-not $TrackFolder) {
            if ($ShowLapHints -and $JsonPath) {
                $IdealLinePath = Join-Path ([IO.Path]::GetTempPath()) '_BuildIdealLine_skip.ai'
            } else {
                throw "使用 -JsonPath/-CsvPath 且未指定 -IdealLinePath 时，需要 -TrackFolder。"
            }
        } else {
            # "指定在哪里就在哪里"：默认不再强制落到 data 子目录。
            $IdealLinePath = Resolve-FsPath (Join-Path (Resolve-FsPath $TrackFolder) 'ideal_line.ai')
        }
    } else {
        # 相对路径按当前工作目录解析，不再依赖 TrackFolder 作为基准。
        $IdealLinePath = Resolve-FsPath $IdealLinePath
    }
} else {
    Show-Usage
    throw "请提供 -Replay 与 -TrackFolder，或提供 -JsonPath / -CsvPath。"
}

if (-not $ShowLapHints) {
    if (-not (Test-Path -LiteralPath $IdealLinePath) -and $TrackFolder) {
        $trackBase = Resolve-FsPath $TrackFolder
        $fallbackTemplate = Join-Path $trackBase 'data\ideal_line.ai'
        if (Test-Path -LiteralPath $fallbackTemplate) {
            $outDir = Split-Path -Parent $IdealLinePath
            if ($outDir -and -not (Test-Path -LiteralPath $outDir)) {
                New-Item -ItemType Directory -Path $outDir -Force | Out-Null
            }
            Copy-Item -LiteralPath $fallbackTemplate -Destination $IdealLinePath -Force
            Write-Host "未找到目标 ideal_line.ai，已从模板复制: $fallbackTemplate -> $IdealLinePath"
        }
    }
    if (-not (Test-Path -LiteralPath $IdealLinePath)) {
        if ($tempWork -and -not $KeepTempJson) { Remove-Item -LiteralPath $tempWork -Recurse -Force -ErrorAction SilentlyContinue }
        throw "找不到 ideal_line.ai: $IdealLinePath"
    }
}

# --- 解析轨迹并写 ideal_line ---

function Parse-CsvLine([string]$line) {
    $cells = New-Object System.Collections.Generic.List[string]
    $cur = New-Object System.Text.StringBuilder
    $inQ = $false
    for ($i = 0; $i -lt $line.Length; $i++) {
        $c = $line[$i]
        if ($c -eq '"') {
            $inQ = -not $inQ
        } elseif (($c -eq ',') -and -not $inQ) {
            [void]$cells.Add($cur.ToString())
            [void]$cur.Clear()
        } else {
            [void]$cur.Append($c)
        }
    }
    [void]$cells.Add($cur.ToString())
    return ,$cells.ToArray()
}

function Get-SfCrossingIndices($j) {
    $cross = New-Object System.Collections.Generic.List[int]
    $nF = $j.currentLapTime.Count
    for ($i = 1; $i -lt $nF; $i++) {
        $a = [int]$j.currentLapTime[$i - 1]
        $b = [int]$j.currentLapTime[$i]
        $lapInc = [int]$j.currentLap[$i] - [int]$j.currentLap[$i - 1]
        if (($a - $b -gt 500) -or ($lapInc -gt 0)) {
            $prev = if ($cross.Count -gt 0) { $cross[$cross.Count - 1] } else { -9999 }
            if (($i - $prev) -gt 2) { [void]$cross.Add($i) }
        }
    }
    return $cross
}

function Measure-ArcJson($j, [int]$i0, [int]$i1Exclusive) {
    $s = 0.0
    $px = $null; $py = $null; $pz = $null
    for ($i = $i0; $i -lt $i1Exclusive; $i++) {
        $x = [double]$j.x[$i]; $y = [double]$j.y[$i]; $z = [double]$j.z[$i]
        if ($null -ne $px) {
            $dx = $x - $px; $dy = $y - $py; $dz = $z - $pz
            $s += [Math]::Sqrt($dx * $dx + $dy * $dy + $dz * $dz)
        }
        $px = $x; $py = $y; $pz = $z
    }
    return $s
}

function Select-TimingSegment($j, [int]$Lap, [double]$MinSegmentMeters) {
    $cross = Get-SfCrossingIndices $j
    if ($cross.Count -lt 2) {
        return @{ Start = -1; End = -1; Length = 0.0; Mode = 'no_crossings' }
    }
    $bestLen = -1.0
    $bestA = -1
    $bestB = -1
    for ($k = 0; $k -lt $cross.Count - 1; $k++) {
        $a = $cross[$k]
        $b = $cross[$k + 1]
        if ([int]$j.currentLap[$a] -ne $Lap) { continue }
        $len = Measure-ArcJson $j $a $b
        if ($len -gt $bestLen) {
            $bestLen = $len
            $bestA = $a
            $bestB = $b
        }
    }
    if ($bestA -lt 0) {
        return @{ Start = -1; End = -1; Length = 0.0; Mode = 'no_match' }
    }
    if ($bestLen -lt $MinSegmentMeters) {
        return @{ Start = -1; End = -1; Length = $bestLen; Mode = 'segment_too_short' }
    }
    return @{ Start = $bestA; End = $bestB; Length = $bestLen; Mode = 'longest_for_lap' }
}

if ($ShowLapHints) {
    if (-not $useJson) { throw "-ShowLapHints 仅支持 JSON（-Replay 或 -JsonPath），不支持 CSV。" }
    $jh = Get-Content -LiteralPath $JsonPath -Raw -Encoding UTF8 | ConvertFrom-Json
    if (-not $jh.currentLap -or -not $jh.currentLapTime) {
        throw "JSON 缺少 currentLap 或 currentLapTime，无法分析计时线。"
    }
    $nH = $jh.currentLap.Count
    if ($jh.currentLapTime.Count -ne $nH) { throw "currentLap 与 currentLapTime 长度不一致。" }
    $xc = Get-SfCrossingIndices $jh
    Write-Host "=== ShowLapHints: $JsonPath ==="
    Write-Host "帧数=$nH  检测到计时线交叉索引数=$($xc.Count)"
    Write-Host "（过线后该帧的 currentLap 即「已开始计时的那一圈」编号，通常从 0 递增）"
    for ($ki = 0; $ki -lt $xc.Count; $ki++) {
        $ix = $xc[$ki]
        Write-Host ("  交叉#{0}: frame={1}  currentLap={2}  currentLapTime={3} ms" -f $ki, $ix, [int]$jh.currentLap[$ix], [int]$jh.currentLapTime[$ix])
    }
    for ($ki = 0; $ki -lt $xc.Count - 1; $ki++) {
        $a = $xc[$ki]
        $b = $xc[$ki + 1]
        $alen = Measure-ArcJson $jh $a $b
        $lapAtStart = [int]$jh.currentLap[$a]
        Write-Host ("  区间 frame {0}..{1}: 起点 currentLap={2}  弧长约 {3:F1} m  （同 Lap 多段时脚本取最长段）" -f $a, $b, $lapAtStart, $alen)
    }
    Write-Host "当前默认 -Lap=$Lap；若飞行圈是「第 3 圈」且 AC 从 0 编号，多为 -Lap 2。"
    if ($tempWork -and (Test-Path -LiteralPath $tempWork) -and -not $KeepTempJson) {
        Remove-Item -LiteralPath $tempWork -Recurse -Force -ErrorAction SilentlyContinue
    }
    exit 0
}

try {
$pts = New-Object System.Collections.Generic.List[object]
$hasPedals = $false
$timingMode = 'n/a'
if ($useJson) {
    $j = Get-Content -LiteralPath $JsonPath -Raw -Encoding UTF8 | ConvertFrom-Json
    if (-not $j.x -or -not $j.y -or -not $j.z) { throw "JSON 缺少 x/y/z 数组（请确认为 acrp 导出）。" }
    if (-not $j.currentLap) { throw "JSON 缺少 currentLap 数组。" }
    $nF = $j.x.Count
    if ($j.y.Count -ne $nF -or $j.z.Count -ne $nF -or $j.currentLap.Count -ne $nF) {
        throw "JSON 中 x/y/z/currentLap 长度不一致。"
    }
    if ($j.gas -and $j.brake -and ($j.gas.Count -eq $nF) -and ($j.brake.Count -eq $nF)) {
        $hasPedals = $true
    }

    $iStart = 0
    $iEnd = $nF
    $timingUsed = $false
    if (-not $UseTimingLine) {
        $timingMode = 'timing_disabled'
    } elseif ($j.currentLapTime -and ($j.currentLapTime.Count -eq $nF)) {
        $seg = Select-TimingSegment $j $Lap $MinSegmentMeters
        if ($seg.Start -ge 0) {
            $iStart = $seg.Start
            $iEnd = $seg.End
            $timingUsed = $true
            $timingMode = $seg.Mode
        } elseif ($seg.Mode -eq 'segment_too_short') {
            $timingMode = 'segment_too_short'
            Write-Warning ("计时线切段: 该 Lap 下最长区间仅 {0:F1} m，低于 -MinSegmentMeters ({1} m)，已放弃切段。可调小 -MinSegmentMeters 或检查录像。" -f $seg.Length, $MinSegmentMeters)
        } elseif ($seg.Mode -eq 'no_crossings') {
            $timingMode = 'no_crossings'
            Write-Warning "录像中未检测到计时线交叉（currentLapTime/圈数变化），已按整段 -Lap 过滤取点。"
        } else {
            $timingMode = 'lap_filter_pending'
        }
    } else {
        $timingMode = 'no_currentLapTime'
        Write-Warning "JSON 无 currentLapTime 或与帧数不一致，已跳过计时线切段，仅按 -Lap 过滤。"
    }

    for ($i = $iStart; $i -lt $iEnd; $i++) {
        if (-not $timingUsed) {
            if ([int]$j.currentLap[$i] -ne $Lap) { continue }
        }
        $g = if ($hasPedals) { [int]$j.gas[$i] } else { 0 }
        $bk = if ($hasPedals) { [int]$j.brake[$i] } else { 0 }
        if ($g -lt 0) { $g = 0 } elseif ($g -gt 255) { $g = 255 }
        if ($bk -lt 0) { $bk = 0 } elseif ($bk -gt 255) { $bk = 255 }
        [void]$pts.Add([pscustomobject]@{
                X = [float][double]$j.x[$i]
                Y = [float][double]$j.y[$i]
                Z = [float][double]$j.z[$i]
                G = $g
                Bk = $bk
            })
    }
    if ($UseTimingLine -and -not $timingUsed) {
        if ($timingMode -eq 'lap_filter_pending') { $timingMode = 'no_segment_for_lap' }
        Write-Warning "未找到起点 currentLap=$Lap 的计时区间（或交叉点不足），已回退为整段 Lap 过滤。可运行 -ShowLapHints 查看每段起点应对的 -Lap，或 -UseTimingLine:`$false。"
    }
} else {
    $timingMode = 'csv'
    $hdr = Get-Content -LiteralPath $CsvPath -TotalCount 1 -Encoding UTF8
    $names = Parse-CsvLine $hdr
    $ixX = [array]::IndexOf($names, 'position.x')
    $ixY = [array]::IndexOf($names, 'position.y')
    $ixZ = [array]::IndexOf($names, 'position.z')
    $ixLap = [array]::IndexOf($names, 'currentLap')
    $ixGas = [array]::IndexOf($names, 'gas')
    $ixBrake = [array]::IndexOf($names, 'brake')
    if ($ixX -lt 0 -or $ixY -lt 0 -or $ixZ -lt 0) { throw "CSV 缺少 position.x/y/z 列，请确认由 acreplay-parser 导出。" }
    if ($ixLap -lt 0) { throw "CSV 缺少 currentLap 列。" }
    if ($ixGas -ge 0 -and $ixBrake -ge 0) { $hasPedals = $true }

    $reader = [IO.StreamReader]::new($CsvPath, [Text.Encoding]::UTF8, $true)
    try {
        [void]$reader.ReadLine()
        while ($null -ne ($line = $reader.ReadLine())) {
            if ([string]::IsNullOrWhiteSpace($line)) { continue }
            $c = Parse-CsvLine $line
            if ($c.Count -le [Math]::Max($ixX, [Math]::Max($ixY, [Math]::Max($ixZ, $ixLap)))) { continue }
            $lapVal = 0
            [void][int]::TryParse($c[$ixLap].Trim(), [ref]$lapVal)
            if ($lapVal -ne $Lap) { continue }
            $x = [double]::Parse($c[$ixX].Trim(), [Globalization.CultureInfo]::InvariantCulture)
            $y = [double]::Parse($c[$ixY].Trim(), [Globalization.CultureInfo]::InvariantCulture)
            $z = [double]::Parse($c[$ixZ].Trim(), [Globalization.CultureInfo]::InvariantCulture)
            $g = 0; $bk = 0
            if ($hasPedals) {
                [void][int]::TryParse($c[$ixGas].Trim(), [ref]$g)
                [void][int]::TryParse($c[$ixBrake].Trim(), [ref]$bk)
            }
            if ($g -lt 0) { $g = 0 } elseif ($g -gt 255) { $g = 255 }
            if ($bk -lt 0) { $bk = 0 } elseif ($bk -gt 255) { $bk = 255 }
            [void]$pts.Add([pscustomobject]@{ X = [float]$x; Y = [float]$y; Z = [float]$z; G = $g; Bk = $bk })
        }
    } finally { $reader.Close() }
}

if ($DedupePlanarMin -gt 0 -and $pts.Count -gt 2) {
    $dd = New-Object System.Collections.Generic.List[object]
    [void]$dd.Add($pts[0])
    for ($di = 1; $di -lt $pts.Count; $di++) {
        $a = $dd[$dd.Count - 1]
        $b = $pts[$di]
        $dh = [Math]::Sqrt([double](($b.X - $a.X) * ($b.X - $a.X) + ($b.Z - $a.Z) * ($b.Z - $a.Z)))
        if ($dh -ge $DedupePlanarMin) { [void]$dd.Add($b) }
    }
    $pts = $dd
}

if ($pts.Count -lt 200) { throw "该圈采样点过少 ($($pts.Count))，请检查 -DriverName / -Lap / -UseTimingLine。" }

$clean = New-Object System.Collections.Generic.List[object]
[void]$clean.Add($pts[0])
for ($i = 1; $i -lt $pts.Count; $i++) {
    $a = $clean[$clean.Count - 1]
    $b = $pts[$i]
    $d = [Math]::Sqrt([double](($b.X - $a.X) * ($b.X - $a.X) + ($b.Z - $a.Z) * ($b.Z - $a.Z)))
    if ($d -lt 80.0) { [void]$clean.Add($b) }
}
$pts = $clean
if ($pts.Count -lt 200) { throw "过滤跳变后点数不足 ($($pts.Count))。" }

$segLen = New-Object double[] ($pts.Count)
$cum = New-Object double[] ($pts.Count)
$cum[0] = 0.0
for ($i = 1; $i -lt $pts.Count; $i++) {
    $dx = [double]$pts[$i].X - [double]$pts[$i - 1].X
    $dy = [double]$pts[$i].Y - [double]$pts[$i - 1].Y
    $dz = [double]$pts[$i].Z - [double]$pts[$i - 1].Z
    $segLen[$i] = [Math]::Sqrt($dx * $dx + $dy * $dy + $dz * $dz)
    $cum[$i] = $cum[$i - 1] + $segLen[$i]
}
$replayTotal = $cum[$pts.Count - 1]
if ($replayTotal -lt 100.0) { throw "该圈弧长异常短 ($replayTotal m)，请换 -Lap 或检查录像。" }

function Get-PointAtDistance([object[]]$p, [double[]]$c, [double]$dist) {
    if ($dist -le 0) { return $p[0] }
    $max = $c[$p.Length - 1]
    if ($dist -ge $max) { return $p[$p.Length - 1] }
    $lo = 0
    $hi = $p.Length - 1
    while ($hi - $lo -gt 1) {
        $mid = [int](($lo + $hi) / 2)
        if ($c[$mid] -le $dist) { $lo = $mid } else { $hi = $mid }
    }
    $i = $lo
    $t = if (($c[$i + 1] - $c[$i]) -gt 1e-6) { ($dist - $c[$i]) / ($c[$i + 1] - $c[$i]) } else { 0.0 }
    $ax = [double]$p[$i].X; $ay = [double]$p[$i].Y; $az = [double]$p[$i].Z
    $bx = [double]$p[$i + 1].X; $by = [double]$p[$i + 1].Y; $bz = [double]$p[$i + 1].Z
    return [pscustomobject]@{
        X = [float]($ax + $t * ($bx - $ax))
        Y = [float]($ay + $t * ($by - $ay))
        Z = [float]($az + $t * ($bz - $az))
    }
}

function Get-Pedal01AtDistance([object[]]$p, [double[]]$c, [double]$dist, [bool]$pickGas) {
    if ($dist -le 0) {
        $v = if ($pickGas) { [double]$p[0].G } else { [double]$p[0].Bk }
        return [float]($v / 255.0)
    }
    $max = $c[$p.Length - 1]
    if ($dist -ge $max) {
        $v = if ($pickGas) { [double]$p[$p.Length - 1].G } else { [double]$p[$p.Length - 1].Bk }
        return [float]($v / 255.0)
    }
    $lo = 0
    $hi = $p.Length - 1
    while ($hi - $lo -gt 1) {
        $mid = [int](($lo + $hi) / 2)
        if ($c[$mid] -le $dist) { $lo = $mid } else { $hi = $mid }
    }
    $i = $lo
    $tt = if (($c[$i + 1] - $c[$i]) -gt 1e-6) { ($dist - $c[$i]) / ($c[$i + 1] - $c[$i]) } else { 0.0 }
    $va = if ($pickGas) { [double]$p[$i].G } else { [double]$p[$i].Bk }
    $vb = if ($pickGas) { [double]$p[$i + 1].G } else { [double]$p[$i + 1].Bk }
    return [float](($va + $tt * ($vb - $va)) / 255.0)
}

$bytes = [IO.File]::ReadAllBytes($IdealLinePath)
$ver = [BitConverter]::ToInt32($bytes, 0)
if ($ver -ne 7) { throw "ideal_line 版本为 $ver，本脚本仅按版本 7 处理。" }
$n = [BitConverter]::ToInt32($bytes, 4)
if ($n -lt 10) { throw "点数异常: $n" }

$oldLens = New-Object float[] $n
for ($i = 0; $i -lt $n; $i++) {
    $o = 16 + $i * 20 + 12
    $oldLens[$i] = [BitConverter]::ToSingle($bytes, $o)
}
$oldMax = [double]$oldLens[$n - 1]
if ($oldMax -lt 1.0) { throw "原线累计长度异常。" }

if ($WhatIf) {
    $pedalNote = if ($hasPedals) { "写入 Gas/Brake" } else { "无油门刹车数据，不改颜色" }
    Write-Host "WhatIf: $IdealLinePath | $n 点 | Lap=$Lap | timing=$timingMode | 采样 $($pts.Count) | 弧长 $replayTotal m | 原线长 $oldMax m | $pedalNote"
    exit 0
}

$bak = $IdealLinePath + ".bak_" + (Get-Date -Format "yyyyMMdd_HHmmss")
Copy-Item -LiteralPath $IdealLinePath -Destination $bak -Force
Write-Host "已备份: $bak"

$newLens = New-Object float[] $n
for ($i = 0; $i -lt $n; $i++) {
    $frac = [double]$oldLens[$i] / $oldMax
    $d = $frac * $replayTotal
    $newLens[$i] = [float]$d
    $q = Get-PointAtDistance $pts $cum $d
    $o = 16 + $i * 20
    [Array]::Copy([BitConverter]::GetBytes($q.X), 0, $bytes, $o, 4)
    [Array]::Copy([BitConverter]::GetBytes($q.Y), 0, $bytes, $o + 4, 4)
    [Array]::Copy([BitConverter]::GetBytes($q.Z), 0, $bytes, $o + 8, 4)
    [Array]::Copy([BitConverter]::GetBytes($newLens[$i]), 0, $bytes, $o + 12, 4)
}

$PointExtraStride = 72
$nEx = [BitConverter]::ToInt32($bytes, 16 + 20 * $n)
$extraStart = 16 + 20 * $n + 4
if ($hasPedals -and ($nEx -eq $n) -and (($bytes.Length - $extraStart) -ge ($n * $PointExtraStride))) {
    $ptArr = $pts.ToArray()
    for ($i = 0; $i -lt $n; $i++) {
        $d = [double]$newLens[$i]
        $gas01 = Get-Pedal01AtDistance $ptArr $cum $d $true
        $brake01 = Get-Pedal01AtDistance $ptArr $cum $d $false
        $eo = $extraStart + $i * $PointExtraStride
        [Array]::Copy([BitConverter]::GetBytes($gas01), 0, $bytes, $eo + 4, 4)
        [Array]::Copy([BitConverter]::GetBytes($brake01), 0, $bytes, $eo + 8, 4)
    }
    Write-Host "已更新 PointsExtra 的 Gas/Brake。"
} elseif ($hasPedals) {
    Write-Warning "PointsExtra 与点数不匹配，已跳过颜色写入。"
}

[IO.File]::WriteAllBytes($IdealLinePath, $bytes)
Write-Host "完成: $IdealLinePath"
}
finally {
    if ($tempWork -and (Test-Path -LiteralPath $tempWork) -and -not $KeepTempJson) {
        Remove-Item -LiteralPath $tempWork -Recurse -Force -ErrorAction SilentlyContinue
    }
}

到这里ACReplay2AILine基本完成，但是还是存在一些问题，他只能修改ailine，并不能凭空生成，所以需要先把原本赛道的ailine拿到，才能改，然后其中未修改的值，可能有一部分是不对的或者不匹配的。

ACReplay Analysis

实现了上面的回放转行车线，我就思考是否可以把轨迹内容输出，并且和地图匹配到一起，这样就能单独看到自己在每个弯的刹车点、速度和开油点和对应的速度了，这样做分析完就可以模板化操作了。

实际想得还是太简单了，游戏内mod的数据给的太少了，赛道边界信息啥的都没给，而且现实中的T1-T14是人为定义的，实际上游戏内根本没有这个弯道定义，游戏内只是对赛道进行了3个segment的分段，要把现实和游戏的轨迹匹配上就有点困难了。

然后再说一个，游戏内是没有经纬度信息的，使用的xyz坐标系统，而现实T1-T14都不是，他们的经纬度信息缺少，这让匹配就更难了。

开始的几次尝试基本都失败了，回放轨迹和赛道匹配不上，比例大小都不正确，其实是缺少了赛道的宽度具体赛道边界曲线信息。

基于此放弃了赛道匹配，直接画轨迹，这个部分没问题，但是弯道匹配还是有误，T1-T14怎么都对不上，反复调整代码也不行，这个流程估计耗时两三个小时，最后放弃了。

直接使用轨迹和刹车点、开油点的逻辑，把每次操作的位置和此时时速都标识出来

然后就得到了这样一张图，我称为 Action 图（操作图），可以清晰看到每个位置大概以多少速度刹车、大概在什么位置开油。

不过还是有点小问题，中间不给油或者保持油门的细节没有

这里比较麻烦的点是油门和刹车的判断，刹多少算刹车，持续多久算一次？同理油门，一开始沟通时没有给到这部分信息，让AI自主判断，但是结果是比较差的，出现各种奇怪情况，比如油门默认高时，不算油门上升，刹车默认高也不算刹车，上升比例要求的太多了，导致细节反馈不出来

反馈给AI以后再次生成，依然错误，甚至越改越偏。但是由于基础代码被改了，没有 commit，导致最后一错到底，无法纠正回来，只好放弃掉这部分 AI，重新梳理逻辑，再重新对话写代码。

反复调试，增加约束调节以后，总算得到了一个正确的图，并且增加用例测试，得到的结果都还行

#Requires -Version 5.1
<#
.SYNOPSIS
  Generic replay lap analyzer: detect brake/throttle onsets and render trajectory markers.
  If replay/corners data files are missing, they are auto-generated from the provided replay.
#>
param(
    [string]$JsonPath = '',
    [string]$TrackFolder = '',
    [string]$CornersJson = '',
    [string]$ReplayPath = '',
    [string]$AcRpPath = '',
    [string]$DriverName = '',
    [string]$OutputPath = '',
    [int]$Lap = 0,
    [bool]$AutoFastestLap = $true,
    [double]$MinSegmentMeters = 50.0,
    [int]$ImageWidth = 1800,
    [int]$ImageHeight = 1350,
    [double]$InnerMarginPercent = 5.0,
    [float]$FontSizeTitle = 20.0,
    [float]$FontSizeMarker = 14.0,
    [double]$BrakeMinSeconds = 0.3,
    [double]$ThrottleMinSeconds = 0.5,
    [int]$BrakePedalThreshold = 25,
    [int]$GasPedalThreshold = 180,
    [double]$GasReapplyMinSeconds = 0.06,
    [int]$GasReapplyThreshold = 60,
    [int]$GasReapplyDelta = 20,
    [int]$GasReapplyBrakeMax = 20,
    [bool]$AllowOverlapThrottleBetweenBrakes = $true,
    [double]$SectorExpandMeters = 20.0,
    [switch]$DebugEventTrace,
    [string]$DebugOutputPath = '',
    [switch]$HideCornerCenterLabel,
    [switch]$NoVerticalFlip,
    [switch]$FlipWorldZ
)

$ErrorActionPreference = 'Stop'
# PS2EXE 嵌入执行时 $PSScriptRoot / $PSCommandPath 可能为空；
# 优先使用进程主模块路径，确保在“当前目录不等于exe目录”时也能稳定定位工具目录。
$toolDir = $null
if ($PSCommandPath) {
    $toolDir = Split-Path -LiteralPath $PSCommandPath
} elseif ($PSScriptRoot) {
    $toolDir = $PSScriptRoot
} else {
    try {
        $exePath = [System.Diagnostics.Process]::GetCurrentProcess().MainModule.FileName
        if ($exePath -and (Test-Path -LiteralPath $exePath)) {
            $toolDir = Split-Path -LiteralPath $exePath
        }
    } catch { }
    if (-not $toolDir) {
        $a0 = [Environment]::GetCommandLineArgs()[0]
        if ($a0 -and (Test-Path -LiteralPath $a0)) {
            $toolDir = Split-Path -LiteralPath $a0
        } else {
            $toolDir = (Get-Location).Path
        }
    }
}
if (-not $toolDir) { throw 'Cannot resolve tool directory (expected exe or .ps1 path).' }
if (-not $TrackFolder) { $TrackFolder = Join-Path (Split-Path $toolDir -Parent) 'zhuhai' }
Add-Type -AssemblyName System.Drawing

$capPath = Join-Path $toolDir 'draw_trajectory_captions.json'
$cap = [pscustomobject]@{ sf = 'S/F'; titlePrefix = 'Replay Lap Analysis'; legend = 'Blue=track Orange=S/F Red=brake Green=throttle' }
if (Test-Path -LiteralPath $capPath) {
    $cj = Get-Content -LiteralPath $capPath -Raw -Encoding UTF8 | ConvertFrom-Json
    if ($cj.sf) { $cap.sf = [string]$cj.sf }
    if ($cj.titlePrefix) { $cap.titlePrefix = [string]$cj.titlePrefix }
    if ($cj.legend) { $cap.legend = [string]$cj.legend }
}

function Resolve-FsPath([string]$Path) {
    if ([string]::IsNullOrWhiteSpace($Path)) { return $Path }
    $p = $Path.Trim()
    while ($p.Length -ge 2 -and $p.StartsWith('"') -and $p.EndsWith('"')) {
        $p = $p.Substring(1, $p.Length - 2).Trim()
    }
    if ($p.StartsWith('~')) {
        $rest = $p.Substring(1).TrimStart('\', '/')
        $p = if ($rest) { Join-Path $HOME $rest } else { $HOME }
    }
    return [IO.Path]::GetFullPath($p)
}

function Get-FileStem([string]$pathOrName, [string]$fallback) {
    if ([string]::IsNullOrWhiteSpace($pathOrName)) { return $fallback }
    $nm = [IO.Path]::GetFileNameWithoutExtension($pathOrName)
    if ([string]::IsNullOrWhiteSpace($nm)) { return $fallback }
    return $nm
}

function Clamp-Int([int]$v, [int]$lo, [int]$hi) {
    if ($v -lt $lo) { return $lo }
    if ($v -gt $hi) { return $hi }
    return $v
}

function Get-SfCrossingIndices($j) {
    $cross = New-Object System.Collections.Generic.List[int]
    if (-not $j.currentLapTime -or ($j.currentLapTime.Count -ne $j.x.Count)) { return $cross }
    for ($i = 1; $i -lt $j.currentLapTime.Count; $i++) {
        $a = [int]$j.currentLapTime[$i - 1]; $b = [int]$j.currentLapTime[$i]
        $lapInc = [int]$j.currentLap[$i] - [int]$j.currentLap[$i - 1]
        if (($a - $b -gt 500) -or ($lapInc -gt 0)) {
            $prev = if ($cross.Count -gt 0) { $cross[$cross.Count - 1] } else { -9999 }
            if (($i - $prev) -gt 2) { [void]$cross.Add($i) }
        }
    }
    return $cross
}

function Measure-ArcJson($j, [int]$i0, [int]$i1Exclusive) {
    $s = 0.0; $px = $null; $py = $null; $pz = $null
    for ($i = $i0; $i -lt $i1Exclusive; $i++) {
        $x = [double]$j.x[$i]; $y = [double]$j.y[$i]; $z = [double]$j.z[$i]
        if ($null -ne $px) {
            $dx = $x - $px; $dy = $y - $py; $dz = $z - $pz
            $s += [Math]::Sqrt($dx * $dx + $dy * $dy + $dz * $dz)
        }
        $px = $x; $py = $y; $pz = $z
    }
    return $s
}

function Select-TimingSegment($j, [int]$LapVal, [double]$MinSeg) {
    $cross = Get-SfCrossingIndices $j
    if ($cross.Count -lt 2) { return @{ Start = -1; End = -1; Length = 0.0; Mode = 'no_crossings' } }
    $bestLen = -1.0; $bestA = -1; $bestB = -1
    for ($k = 0; $k -lt $cross.Count - 1; $k++) {
        $a = $cross[$k]; $b = $cross[$k + 1]
        if ([int]$j.currentLap[$a] -ne $LapVal) { continue }
        $len = Measure-ArcJson $j $a $b
        if ($len -gt $bestLen) { $bestLen = $len; $bestA = $a; $bestB = $b }
    }
    if ($bestA -lt 0) { return @{ Start = -1; End = -1; Length = 0.0; Mode = 'no_match' } }
    if ($bestLen -lt $MinSeg) { return @{ Start = -1; End = -1; Length = $bestLen; Mode = 'segment_too_short' } }
    return @{ Start = $bestA; End = $bestB; Length = $bestLen; Mode = 'ok' }
}

function Select-FastestTimingSegment($j, [double]$MinSeg) {
    $cross = Get-SfCrossingIndices $j
    if ($cross.Count -lt 2) { return @{ Start = -1; End = -1; Length = 0.0; Mode = 'no_crossings'; Lap = -1; TimeMs = -1 } }

    $best = $null
    for ($k = 0; $k -lt $cross.Count - 1; $k++) {
        $a = $cross[$k]; $b = $cross[$k + 1]
        $lapVal = [int]$j.currentLap[$a]
        $len = Measure-ArcJson $j $a $b
        if ($len -lt $MinSeg) { continue }

        $timeMs = -1
        if ($j.PSObject.Properties.Name -contains 'currentLapTime') {
            $ti = [int]$j.currentLapTime[[Math]::Max($a, $b - 1)]
            if ($ti -gt 0) { $timeMs = $ti }
        }
        if ($timeMs -le 0) {
            $dt = Get-FrameDtSeconds $j
            $timeMs = [int][Math]::Round(($b - $a) * $dt * 1000.0)
        }

        $cand = @{
            Start = $a
            End = $b
            Length = $len
            Mode = 'ok'
            Lap = $lapVal
            TimeMs = $timeMs
        }
        if ($null -eq $best -or $cand.TimeMs -lt $best.TimeMs) {
            $best = $cand
        }
    }

    if ($null -eq $best) { return @{ Start = -1; End = -1; Length = 0.0; Mode = 'no_valid_segment'; Lap = -1; TimeMs = -1 } }
    return $best
}

function Get-SpeedKmh($j, [int]$fi) {
    $vx = [double]$j.velocityX[$fi]; $vy = [double]$j.velocityY[$fi]; $vz = [double]$j.velocityZ[$fi]
    return [Math]::Sqrt($vx * $vx + $vy * $vy + $vz * $vz) * 3.6
}

function Get-FrameDtSeconds($j) {
    if ($j.PSObject.Properties.Name -contains 'recordingInterval') {
        $ri = [double]$j.recordingInterval
        if ($ri -gt 0 -and $ri -le 100.0) { return $ri / 1000.0 }
        if ($ri -gt 100.0) { return 1.0 / $ri }
    }
    return (1.0 / 60.0)
}

function Get-BoundariesFromSegmentEnds([double[]]$ends) {
    if ($ends.Count -ne 14) { throw 'segmentEndFraction must have 14 elements, last=1.0' }
    if ([Math]::Abs($ends[13] - 1.0) -gt 0.001) { throw 'segmentEndFraction[13] must be 1.0' }
    $b = New-Object double[] 15
    $b[0] = 0.0
    for ($i = 0; $i -lt 14; $i++) { $b[$i + 1] = $ends[$i] }
    return $b
}

function Find-KRangeForArc([double[]]$sArr, [double]$lapLen, [double]$f0, [double]$f1, [int]$m) {
    $s0 = [Math]::Max(0.0, $f0 * $lapLen)
    $s1 = [Math]::Min($lapLen, $f1 * $lapLen)
    $k0 = 0
    for ($k = 0; $k -lt $m; $k++) {
        if ($sArr[$k] -ge $s0) { $k0 = $k; break }
    }
    $k1 = $m - 1
    for ($k = $m - 1; $k -ge 0; $k--) {
        if ($sArr[$k] -le $s1) { $k1 = $k; break }
    }
    if ($k1 -lt $k0) { $k1 = $k0 }
    return $k0, $k1
}

function Find-KClosestToS([double[]]$sArr, [double]$targetS, [int]$k0, [int]$k1) {
    $best = $k0
    $bd = [Math]::Abs($sArr[$k0] - $targetS)
    for ($k = $k0; $k -le $k1; $k++) {
        $d = [Math]::Abs($sArr[$k] - $targetS)
        if ($d -lt $bd) { $bd = $d; $best = $k }
    }
    return $best
}

function Find-FirstSustainedAbove([int[]]$vals, [int]$k0, [int]$k1, [int]$thr, [int]$minFrames) {
    if ($minFrames -lt 1) { $minFrames = 1 }
    for ($start = $k0; $start -le $k1; $start++) {
        if ($vals[$start] -lt $thr) { continue }
        $ok = $true
        for ($i = 0; $i -lt $minFrames; $i++) {
            $kk = $start + $i
            if ($kk -gt $k1) { $ok = $false; break }
            if ($vals[$kk] -lt $thr) { $ok = $false; break }
        }
        if ($ok) { return $start }
    }
    return -1
}

function Find-FirstRisingSustainedAbove([int[]]$vals, [int]$k0, [int]$k1, [int]$thr, [int]$minFrames) {
    if ($minFrames -lt 1) { $minFrames = 1 }
    $st0 = [Math]::Max(1, $k0)
    for ($start = $st0; $start -le $k1; $start++) {
        # Rising edge: previous frame below threshold, current frame reaches threshold.
        if ($vals[$start - 1] -ge $thr) { continue }
        if ($vals[$start] -lt $thr) { continue }
        $ok = $true
        for ($i = 0; $i -lt $minFrames; $i++) {
            $kk = $start + $i
            if ($kk -gt $k1) { $ok = $false; break }
            if ($vals[$kk] -lt $thr) { $ok = $false; break }
        }
        if ($ok) { return $start }
    }
    return -1
}

function Find-FirstGasReapply([int[]]$gasVals, [int[]]$brkVals, [int]$k0, [int]$k1, [int]$minGas, [int]$minDelta, [int]$brakeMax, [int]$minFrames) {
    if ($minFrames -lt 1) { $minFrames = 1 }
    $st0 = [Math]::Max(1, $k0)
    for ($start = $st0; $start -le $k1; $start++) {
        if ($brkVals[$start] -gt $brakeMax) { continue }
        if ($gasVals[$start] -lt $minGas) { continue }
        if (($gasVals[$start] - $gasVals[$start - 1]) -lt $minDelta) { continue }
        $ok = $true
        for ($i = 0; $i -lt $minFrames; $i++) {
            $kk = $start + $i
            if ($kk -gt $k1) { $ok = $false; break }
            if ($gasVals[$kk] -lt $minGas) { $ok = $false; break }
            if ($brkVals[$kk] -gt $brakeMax) { $ok = $false; break }
        }
        if ($ok) { return $start }
    }
    return -1
}

function Find-FirstGasReapplyOverlap([int[]]$gasVals, [int]$k0, [int]$k1, [int]$minGas, [int]$minDelta, [int]$minFrames) {
    if ($minFrames -lt 1) { $minFrames = 1 }
    $st0 = [Math]::Max(1, $k0)
    for ($start = $st0; $start -le $k1; $start++) {
        if ($gasVals[$start] -lt $minGas) { continue }
        if (($gasVals[$start] - $gasVals[$start - 1]) -lt $minDelta) { continue }
        $ok = $true
        for ($i = 0; $i -lt $minFrames; $i++) {
            $kk = $start + $i
            if ($kk -gt $k1) { $ok = $false; break }
            if ($gasVals[$kk] -lt $minGas) { $ok = $false; break }
        }
        if ($ok) { return $start }
    }
    return -1
}

function Get-ContiguousRunEnd([int[]]$vals, [int]$start, [int]$k1, [int]$thr) {
    $e = $start
    for ($k = $start; $k -le $k1; $k++) {
        if ($vals[$k] -ge $thr) { $e = $k } else { break }
    }
    return $e
}

function Get-LongestRunAbove([int[]]$vals, [int]$k0, [int]$k1, [int]$thr) {
    if ($k1 -lt $k0) { return 0 }
    $best = 0
    $cur = 0
    for ($k = $k0; $k -le $k1; $k++) {
        if ($vals[$k] -ge $thr) {
            $cur++
            if ($cur -gt $best) { $best = $cur }
        } else {
            $cur = 0
        }
    }
    return $best
}

function New-CjkDrawingFont([float]$emSize, [System.Drawing.FontStyle]$style) {
    $unit = [System.Drawing.GraphicsUnit]::Point
    foreach ($n in @('Microsoft YaHei UI', 'Microsoft YaHei', 'SimHei', 'Segoe UI')) {
        try {
            $fam = New-Object System.Drawing.FontFamily $n
            if ($fam.IsStyleAvailable($style)) { return [System.Drawing.Font]::new($fam, $emSize, $style, $unit) }
        } catch { }
    }
    return [System.Drawing.Font]::new('Segoe UI', $emSize, $style, $unit)
}

function Ensure-ReplayJson([string]$TargetJsonPath, [string]$ReplayPathIn, [string]$AcRpPathIn, [string]$DriverNameIn) {
    if (Test-Path -LiteralPath $TargetJsonPath) { return }
    $acrp = if ([string]::IsNullOrWhiteSpace($AcRpPathIn)) { Join-Path $toolDir 'acrp.exe' } else { Resolve-FsPath $AcRpPathIn }
    if (-not (Test-Path -LiteralPath $acrp)) {
        throw "Replay JSON missing and acrp.exe not found: $acrp"
    }

    $replay = $ReplayPathIn
    if ([string]::IsNullOrWhiteSpace($replay)) {
        $rp = @(Get-ChildItem -LiteralPath $toolDir -Filter *.acreplay -File | Sort-Object LastWriteTime -Descending)
        if ($rp.Count -lt 1) { throw "Replay JSON missing and no .acreplay found in $toolDir" }
        $replay = $rp[0].FullName
    } else {
        $replay = Resolve-FsPath $replay
    }
    if (-not (Test-Path -LiteralPath $replay)) { throw "Replay file not found: $replay" }

    $outDir = Split-Path -Parent $TargetJsonPath
    if ($outDir -and -not (Test-Path -LiteralPath $outDir)) {
        New-Item -ItemType Directory -Path $outDir -Force | Out-Null
    }

    $tempWork = Join-Path ([IO.Path]::GetTempPath()) ('ac_lap_' + [guid]::NewGuid().ToString('N'))
    New-Item -ItemType Directory -Path $tempWork -Force | Out-Null
    $outPrefix = Join-Path $tempWork 'acrp_out'
    try {
        $argList = New-Object System.Collections.Generic.List[string]
        [void]$argList.Add('-o')
        [void]$argList.Add($outPrefix)
        if (-not [string]::IsNullOrWhiteSpace($DriverNameIn)) {
            [void]$argList.Add('--driver-name')
            [void]$argList.Add($DriverNameIn)
        }
        [void]$argList.Add($replay)

        Write-Host "Generating replay JSON via acrp: $replay"
        $proc = Start-Process -FilePath $acrp -ArgumentList $argList.ToArray() -Wait -PassThru -NoNewWindow
        if ($proc.ExitCode -ne 0) { throw "acrp.exe exit code $($proc.ExitCode)" }

        $jsonFiles = @(Get-ChildItem -LiteralPath $tempWork -Filter *.json -File | Sort-Object LastWriteTime -Descending)
        if ($jsonFiles.Count -lt 1) { throw "acrp generated no JSON in: $tempWork" }
        if ($jsonFiles.Count -gt 1 -and [string]::IsNullOrWhiteSpace($DriverNameIn)) {
            throw "acrp generated multiple JSON files; pass -DriverName to pick one."
        }
        Copy-Item -LiteralPath $jsonFiles[0].FullName -Destination $TargetJsonPath -Force
        Write-Host "Generated: $TargetJsonPath"
    } finally {
        Remove-Item -LiteralPath $tempWork -Recurse -Force -ErrorAction SilentlyContinue
    }
}

function Build-CornerJsonFromReplay($j, [string]$TargetPath, [int]$LapVal, [double]$MinSegMeters, [double]$DedupMinGapMeters, [bool]$AutoFastestLapVal) {
    $seg = if ($AutoFastestLapVal) { Select-FastestTimingSegment $j $MinSegMeters } else { Select-TimingSegment $j $LapVal $MinSegMeters }
    if ($seg.Mode -ne 'ok' -or $seg.Start -lt 0) { throw "Cannot build corners: timing segment $($seg.Mode)" }
    $iStart = $seg.Start; $iEnd = $seg.End
    $idx = New-Object System.Collections.Generic.List[int]
    for ($i = $iStart; $i -lt $iEnd; $i++) { [void]$idx.Add($i) }
    if ($idx.Count -lt 200) { throw "Cannot build corners: too few frames ($($idx.Count))" }

    $m = $idx.Count
    $s = New-Object double[] $m
    $brk = New-Object int[] $m
    for ($k = 0; $k -lt $m; $k++) {
        $fi = $idx[$k]
        if ($k -gt 0) {
            $pi = $idx[$k - 1]
            $dx = [double]$j.x[$fi] - [double]$j.x[$pi]
            $dy = [double]$j.y[$fi] - [double]$j.y[$pi]
            $dz = [double]$j.z[$fi] - [double]$j.z[$pi]
            $s[$k] = $s[$k - 1] + [Math]::Sqrt($dx * $dx + $dy * $dy + $dz * $dz)
        }
        $brk[$k] = [int]$j.brake[$fi]
    }
    $lapLen = $s[$m - 1]
    if ($lapLen -lt 100.0) { throw "Cannot build corners: lap length abnormal ($lapLen)" }

    $cand = New-Object System.Collections.Generic.List[object]
    for ($k = 1; $k -lt $m; $k++) {
        $prev = $brk[$k - 1]; $cur = $brk[$k]
        $isOnset = ($cur -ge 35 -and $prev -lt 25) -or ($cur -ge 22 -and $prev -lt 12) -or (($cur - $prev) -ge 20 -and $cur -ge 18)
        if ($isOnset) {
            [void]$cand.Add([pscustomobject]@{
                K = $k
                S = $s[$k]
                Fraction = ($s[$k] / $lapLen)
                Score = ($cur + [Math]::Max(0, $cur - $prev))
            })
        }
    }
    if ($cand.Count -lt 14) { throw "Cannot build corners: brake onset candidates <14 ($($cand.Count))" }

    $selected = New-Object System.Collections.Generic.List[object]
    foreach ($c in ($cand | Sort-Object Score -Descending)) {
        if ($selected.Count -ge 14) { break }
        $ok = $true
        foreach ($slt in $selected) {
            $d = [Math]::Abs($c.S - $slt.S)
            $dc = [Math]::Min($d, $lapLen - $d)
            if ($dc -lt $DedupMinGapMeters) { $ok = $false; break }
        }
        if ($ok) { [void]$selected.Add($c) }
    }
    if ($selected.Count -lt 14) {
        foreach ($c in ($cand | Sort-Object Score -Descending)) {
            if ($selected.Count -ge 14) { break }
            $exists = $false
            foreach ($slt in $selected) { if ([int]$slt.K -eq [int]$c.K) { $exists = $true; break } }
            if (-not $exists) { [void]$selected.Add($c) }
        }
    }
    if ($selected.Count -lt 14) { throw "Cannot build corners: selected <14 ($($selected.Count))" }

    $bf = @($selected | Sort-Object Fraction | Select-Object -First 14 | ForEach-Object { [double]$_.Fraction })
    $ends = @()
    for ($i = 0; $i -lt 13; $i++) { $ends += [Math]::Round((($bf[$i] + $bf[$i + 1]) / 2.0), 6) }
    $ends += 1.0

    $b = @(0.0) + $ends
    $center = @()
    for ($i = 0; $i -lt 14; $i++) { $center += [Math]::Round((($b[$i] + $b[$i + 1]) / 2.0), 6) }

    $obj = [ordered]@{
        _comment = "Auto-generated by DrawZhuhaiLapCorners.ps1 from replay brake onsets."
        _comment2 = "segmentEndFraction[13] fixed at 1.0; cornerCenterFraction is sector midpoint."
        segmentEndFraction = $ends
        cornerCenterFraction = $center
    }
    $outDir = Split-Path -Parent $TargetPath
    if ($outDir -and -not (Test-Path -LiteralPath $outDir)) {
        New-Item -ItemType Directory -Path $outDir -Force | Out-Null
    }
    ($obj | ConvertTo-Json -Depth 6) | Set-Content -LiteralPath $TargetPath -Encoding UTF8
    Write-Host "Generated: $TargetPath"
}

$ReplayPath = Resolve-FsPath $ReplayPath
$legacyJson = Join-Path $toolDir 'zhuhai_replay_out_elmagnifico.json'
$legacyCorners = Join-Path $toolDir 'zhuhai_t1_t14_apex_fractions.json'

if ([string]::IsNullOrWhiteSpace($JsonPath)) {
    if (-not [string]::IsNullOrWhiteSpace($ReplayPath)) {
        $rpDir = Split-Path -Parent $ReplayPath
        $rpStem = Get-FileStem $ReplayPath 'replay'
        $JsonPath = Join-Path $rpDir ($rpStem + '_replay.json')
    } elseif (Test-Path -LiteralPath $legacyJson) {
        $JsonPath = $legacyJson
    } else {
        throw "Please provide -ReplayPath or -JsonPath."
    }
}
if ([string]::IsNullOrWhiteSpace($CornersJson)) {
    if (-not [string]::IsNullOrWhiteSpace($ReplayPath)) {
        $rpDir = Split-Path -Parent $ReplayPath
        $rpStem = Get-FileStem $ReplayPath 'replay'
        $CornersJson = Join-Path $rpDir ($rpStem + '_corners.json')
    } elseif (Test-Path -LiteralPath $legacyCorners) {
        $CornersJson = $legacyCorners
    } else {
        $jDir = Split-Path -Parent $JsonPath
        $jStem = Get-FileStem $JsonPath 'replay'
        $CornersJson = Join-Path $jDir ($jStem + '_corners.json')
    }
}
if ([string]::IsNullOrWhiteSpace($OutputPath)) {
    if (-not [string]::IsNullOrWhiteSpace($ReplayPath)) {
        $rpDir = Split-Path -Parent $ReplayPath
        $rpStem = Get-FileStem $ReplayPath 'replay'
        $OutputPath = Join-Path $rpDir ($rpStem + '_brake_throttle_points.png')
    } else {
        $jDir = Split-Path -Parent $JsonPath
        $jStem = Get-FileStem $JsonPath 'replay'
        $OutputPath = Join-Path $jDir ($jStem + '_brake_throttle_points.png')
    }
}
if ([string]::IsNullOrWhiteSpace($DebugOutputPath)) {
    $DebugOutputPath = [IO.Path]::ChangeExtension($OutputPath, '.debug.csv')
}

$JsonPath = Resolve-FsPath $JsonPath
$CornersJson = Resolve-FsPath $CornersJson
$OutputPath = Resolve-FsPath $OutputPath
$DebugOutputPath = Resolve-FsPath $DebugOutputPath
Ensure-ReplayJson $JsonPath $ReplayPath $AcRpPath $DriverName

$j = Get-Content -LiteralPath $JsonPath -Raw -Encoding UTF8 | ConvertFrom-Json
if (-not (Test-Path -LiteralPath $CornersJson)) {
    Build-CornerJsonFromReplay $j $CornersJson $Lap $MinSegmentMeters 28.0 $AutoFastestLap
}

$apexObj = Get-Content -LiteralPath $CornersJson -Raw -Encoding UTF8 | ConvertFrom-Json
if (-not $apexObj.segmentEndFraction) { throw 'CornersJson needs segmentEndFraction[14] ending with 1.0' }
$se = @([double[]]@($apexObj.segmentEndFraction))
$boundaries = Get-BoundariesFromSegmentEnds $se
$cornerCenter = $null
if ($apexObj.cornerCenterFraction) {
    $cornerCenter = @([double[]]@($apexObj.cornerCenterFraction))
    if ($cornerCenter.Count -ne 14) { throw 'cornerCenterFraction must have 14 elements if set' }
}

$nF = $j.x.Count
if ($j.velocityX.Count -ne $nF) { throw 'JSON needs velocityX/Y/Z same length as x.' }

$dt = Get-FrameDtSeconds $j
$brkFrames = [int][math]::Ceiling($BrakeMinSeconds / $dt)
$gasFrames = [int][math]::Ceiling($ThrottleMinSeconds / $dt)
$gasReapplyFrames = [int][math]::Ceiling($GasReapplyMinSeconds / $dt)
Write-Host "Frame dt=${dt}s  brake>=${BrakeMinSeconds}s -> ${brkFrames} frames  throttle>=${ThrottleMinSeconds}s -> ${gasFrames} frames"

$seg = if ($AutoFastestLap) { Select-FastestTimingSegment $j $MinSegmentMeters } else { Select-TimingSegment $j $Lap $MinSegmentMeters }
$iStart = 0; $iEnd = $nF; $timingUsed = $false
if ($seg.Mode -eq 'ok' -and $seg.Start -ge 0) {
    $iStart = $seg.Start; $iEnd = $seg.End; $timingUsed = $true
    if ($AutoFastestLap) {
        $Lap = [int]$seg.Lap
        Write-Host "Timing (fastest lap): lap=$Lap time_ms=$($seg.TimeMs) frames $($seg.Start)..$($seg.End) length_m=$([math]::Round($seg.Length,1))"
    } else {
        Write-Host "Timing: frames $($seg.Start)..$($seg.End) length_m=$([math]::Round($seg.Length,1))"
    }
} else {
    Write-Warning "Timing: $($seg.Mode)"
}

$idx = New-Object System.Collections.Generic.List[int]
for ($i = $iStart; $i -lt $iEnd; $i++) {
    if (-not $timingUsed) {
        if ([int]$j.currentLap[$i] -ne $Lap) { continue }
    }
    [void]$idx.Add($i)
}
if ($idx.Count -lt 200) { throw "Too few frames: $($idx.Count)" }

$m = $idx.Count
$s = New-Object double[] $m
$sp = New-Object double[] $m
$brk = New-Object int[] $m
$gas = New-Object int[] $m
$xs = New-Object double[] $m
$zs = New-Object double[] $m
for ($k = 0; $k -lt $m; $k++) {
    $fi = $idx[$k]
    $xs[$k] = [double]$j.x[$fi]; $zs[$k] = [double]$j.z[$fi]
    if ($k -gt 0) {
        $pi = $idx[$k - 1]
        $dx = [double]$j.x[$fi] - [double]$j.x[$pi]
        $dy = [double]$j.y[$fi] - [double]$j.y[$pi]
        $dz = [double]$j.z[$fi] - [double]$j.z[$pi]
        $s[$k] = $s[$k - 1] + [Math]::Sqrt($dx * $dx + $dy * $dy + $dz * $dz)
    }
    $sp[$k] = Get-SpeedKmh $j $fi
    $brk[$k] = [int]$j.brake[$fi]
    $gas[$k] = [int]$j.gas[$fi]
}

$lapLen = $s[$m - 1]
if ($lapLen -lt 100.0) { throw "Lap length abnormal: $lapLen" }

$xmin = ($xs | Measure-Object -Minimum).Minimum
$xmax = ($xs | Measure-Object -Maximum).Maximum
$zmin = ($zs | Measure-Object -Minimum).Minimum
$zmax = ($zs | Measure-Object -Maximum).Maximum
$innerFrac = [Math]::Max(0.0, [Math]::Min(0.45, $InnerMarginPercent / 100.0))
$bmpW = $ImageWidth; $bmpH = $ImageHeight
$iw = $bmpW * (1.0 - 2.0 * $innerFrac); $ih = $bmpH * (1.0 - 2.0 * $innerFrac)
$rw = [Math]::Max(1e-9, $xmax - $xmin); $rz = [Math]::Max(1e-9, $zmax - $zmin)
$sc = [Math]::Min($iw / $rw, $ih / $rz)
$offX = $bmpW * $innerFrac + ($iw - $sc * $rw) / 2.0
$offZ = $bmpH * $innerFrac + ($ih - $sc * $rz) / 2.0

$pxi = New-Object int[] $m
$pzi = New-Object int[] $m
for ($k = 0; $k -lt $m; $k++) {
    $pxd = $offX + ($xs[$k] - $xmin) * $sc
    if ($FlipWorldZ.IsPresent) { $pzd = $offZ + ($zs[$k] - $zmin) * $sc }
    else { $pzd = $offZ + ($zmax - $zs[$k]) * $sc }
    $pxi[$k] = Clamp-Int ([int][Math]::Round($pxd)) 0 ($bmpW - 1)
    $pzi[$k] = Clamp-Int ([int][Math]::Round($pzd)) 0 ($bmpH - 1)
}
if (-not $NoVerticalFlip.IsPresent) {
    for ($k = 0; $k -lt $m; $k++) { $pzi[$k] = $bmpH - 1 - $pzi[$k] }
}

$bmp = New-Object System.Drawing.Bitmap $bmpW, $bmpH
$g = [System.Drawing.Graphics]::FromImage($bmp)
$g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
$g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::AntiAlias
$g.Clear([System.Drawing.Color]::White)
$fontTitle = New-CjkDrawingFont $FontSizeTitle ([System.Drawing.FontStyle]::Bold)
$fontMk = New-CjkDrawingFont $FontSizeMarker ([System.Drawing.FontStyle]::Bold)
$brushTxt = New-Object System.Drawing.SolidBrush ([System.Drawing.Color]::FromArgb(240, 30, 30, 30))
$penTrace = New-Object System.Drawing.Pen ([System.Drawing.Color]::FromArgb(200, 40, 90, 200)), 3
$brushRed = New-Object System.Drawing.SolidBrush ([System.Drawing.Color]::FromArgb(230, 200, 40, 40))
$brushGreen = New-Object System.Drawing.SolidBrush ([System.Drawing.Color]::FromArgb(230, 30, 150, 50))
$brushSf = New-Object System.Drawing.SolidBrush ([System.Drawing.Color]::FromArgb(255, 200, 130, 0))
$penLeader = New-Object System.Drawing.Pen ([System.Drawing.Color]::FromArgb(160, 90, 90, 90)), 1.0

for ($k = 1; $k -lt $m; $k++) {
    $g.DrawLine($penTrace, $pxi[$k - 1], $pzi[$k - 1], $pxi[$k], $pzi[$k])
}

$occupied = New-Object 'System.Collections.Generic.List[System.Drawing.RectangleF]'

function Test-RectOverlap([System.Drawing.RectangleF]$a, [System.Drawing.RectangleF]$b, [float]$pad) {
    $ax1 = $a.Left - $pad; $ay1 = $a.Top - $pad; $ax2 = $a.Right + $pad; $ay2 = $a.Bottom + $pad
    $bx1 = $b.Left - $pad; $by1 = $b.Top - $pad; $bx2 = $b.Right + $pad; $by2 = $b.Bottom + $pad
    return -not (($ax2 -lt $bx1) -or ($ax1 -gt $bx2) -or ($ay2 -lt $by1) -or ($ay1 -gt $by2))
}

function New-LabelPlacement {
    param($Graphics, $Font, [string]$Text, [int]$cx, [int]$cy, [int]$imgW, [int]$imgH, $Occupied, [float[]]$OffsetCandidates)
    $sz = $Graphics.MeasureString($Text, $Font)
    $w = $sz.Width + 6; $h = $sz.Height + 4
    $pad = [float]4
    for ($ci = 0; $ci -lt $OffsetCandidates.Length; $ci += 2) {
        $tx = [float]($cx + $OffsetCandidates[$ci]); $ty = [float]($cy + $OffsetCandidates[$ci + 1])
        if ($tx + $w -gt $imgW - 4) { $tx = [float]($imgW - 4 - $w) }
        if ($tx -lt 4) { $tx = 4 }
        if ($ty + $h -gt $imgH - 4) { $ty = [float]($imgH - 4 - $h) }
        if ($ty -lt 4) { $ty = 4 }
        $rc = [System.Drawing.RectangleF]::new($tx, $ty, $w, $h)
        $hit = $false
        foreach ($o in $Occupied) { if (Test-RectOverlap $rc $o $pad) { $hit = $true; break } }
        if (-not $hit) {
            [void]$Occupied.Add($rc)
            return @{ Tx = $tx; Ty = $ty; W = $w; H = $h }
        }
    }
    # Fallback: radial search around anchor to minimize collisions in dense areas.
    for ($rad = 26.0; $rad -le 190.0; $rad += 12.0) {
        for ($ang = 0.0; $ang -lt 360.0; $ang += 20.0) {
            $rx = [Math]::Cos($ang * [Math]::PI / 180.0) * $rad
            $ry = [Math]::Sin($ang * [Math]::PI / 180.0) * $rad
            $tx = [float]($cx + $rx)
            $ty = [float]($cy + $ry)
            if ($tx + $w -gt $imgW - 4) { $tx = [float]($imgW - 4 - $w) }
            if ($tx -lt 4) { $tx = 4 }
            if ($ty + $h -gt $imgH - 4) { $ty = [float]($imgH - 4 - $h) }
            if ($ty -lt 4) { $ty = 4 }
            $rc = [System.Drawing.RectangleF]::new($tx, $ty, $w, $h)
            $hit = $false
            foreach ($o in $Occupied) { if (Test-RectOverlap $rc $o $pad) { $hit = $true; break } }
            if (-not $hit) {
                [void]$Occupied.Add($rc)
                return @{ Tx = $tx; Ty = $ty; W = $w; H = $h }
            }
        }
    }
    # Last resort: place at corner to guarantee visibility.
    $tx0 = [float]4; $ty0 = [float]4
    $rc0 = [System.Drawing.RectangleF]::new($tx0, $ty0, $w, $h)
    [void]$Occupied.Add($rc0)
    return @{ Tx = $tx0; Ty = $ty0; W = $w; H = $h }
}

function Draw-StringWithLeader {
    param($Graphics, $Font, $Brush, $PenL, [int]$cx, [int]$cy, [string]$Text, $Place)
    $Graphics.DrawString($Text, $Font, $Brush, $Place.Tx, $Place.Ty)
    $mx = $Place.Tx + $Place.W / 2.0; $my = $Place.Ty + $Place.H / 2.0
    $Graphics.DrawLine($PenL, [float]$cx, [float]$cy, $mx, $my)
}

$sfOff = [float[]]@(20.0, -28.0, -120.0, -28.0, 20.0, 22.0)
$sfPl = New-LabelPlacement $g $fontMk $cap.sf $pxi[0] $pzi[0] $bmpW $bmpH $occupied $sfOff
$g.FillEllipse($brushSf, $pxi[0] - 10, $pzi[0] - 10, 20, 20)
Draw-StringWithLeader $g $fontMk $brushTxt $penLeader $pxi[0] $pzi[0] $cap.sf $sfPl

$bOff = [float[]]@(16.0, -28.0, -120.0, -28.0, 20.0, 22.0, -130.0, 24.0, 95.0, -34.0, 110.0, 12.0)
$gOff = [float[]]@(-16.0, 26.0, 90.0, 26.0, -26.0, -18.0, 110.0, -24.0, -120.0, 30.0, 24.0, 44.0)

$prevBrakeRunEnd = -1
$prevGasRunEnd = -1
$events = New-Object System.Collections.Generic.List[object]
$debugRows = New-Object System.Collections.Generic.List[object]
for ($ti = 0; $ti -lt 14; $ti++) {
    $f0 = $boundaries[$ti]; $f1 = $boundaries[$ti + 1]
    $sLo = [Math]::Max(0.0, ($f0 * $lapLen) - $SectorExpandMeters)
    $sHi = [Math]::Min($lapLen, ($f1 * $lapLen) + $SectorExpandMeters)
    $ff0 = $sLo / $lapLen
    $ff1 = $sHi / $lapLen
    $k0, $k1 = Find-KRangeForArc $s $lapLen $ff0 $ff1 $m

    # Avoid repeated brake markers when one long brake run spans adjacent sectors.
    $searchK0 = [Math]::Max($k0, $prevBrakeRunEnd + 1)
    $bk = Find-FirstRisingSustainedAbove $brk $searchK0 $k1 $BrakePedalThreshold $brkFrames
    $brkEnd = -1
    if ($bk -ge 0) {
        $brkEnd = Get-ContiguousRunEnd $brk $bk $k1 $BrakePedalThreshold
        if ($brkEnd -gt $prevBrakeRunEnd) { $prevBrakeRunEnd = $brkEnd }
    }

    $gasFrom = $k0
    if ($brkEnd -ge 0) { $gasFrom = [Math]::Min($k1, $brkEnd + 1) }
    $gasSearchK0 = [Math]::Max($gasFrom, $prevGasRunEnd + 1)

    $tkRise = Find-FirstRisingSustainedAbove $gas $gasSearchK0 $k1 $GasPedalThreshold $gasFrames
    $tkSustain = -1
    $tkReapply = -1
    $tk = $tkRise
    $tkSource = 'rise'
    if ($tk -lt 0) {
        # Fallback: if no clean rising edge exists in this window, still capture first sustained high-gas point.
        $tkSustain = Find-FirstSustainedAbove $gas $gasSearchK0 $k1 $GasPedalThreshold $gasFrames
        $tk = $tkSustain
        $tkSource = 'sustain'
    }
    if ($tk -lt 0) {
        # Fallback 2: capture lower-threshold throttle reapply when speed rises but full gas threshold isn't reached.
        $tkReapply = Find-FirstGasReapply $gas $brk $gasSearchK0 $k1 $GasReapplyThreshold $GasReapplyDelta $GasReapplyBrakeMax $gasReapplyFrames
        $tk = $tkReapply
        $tkSource = 'reapply'
    }
    if ($tk -lt 0) { $tkSource = 'none' }
    if ($tk -ge 0) {
        $gasEnd = Get-ContiguousRunEnd $gas $tk $k1 $GasPedalThreshold
        if ($gasEnd -gt $prevGasRunEnd) { $prevGasRunEnd = $gasEnd }
    }

    if ($bk -ge 0) {
        [void]$events.Add([pscustomobject]@{
            K = $bk
            Kind = 'brake'
            Sector = ($ti + 1)
            Source = 'rise'
            GasValue = 0
            Speed = [int][math]::Round($sp[$bk], 0)
            Px = $pxi[$bk]
            Py = $pzi[$bk]
        })
    }

    if ($tk -ge 0) {
        [void]$events.Add([pscustomobject]@{
            K = $tk
            Kind = 'gas'
            Sector = ($ti + 1)
            Source = $tkSource
            GasValue = [int]$gas[$tk]
            Speed = [int][math]::Round($sp[$tk], 0)
            Px = $pxi[$tk]
            Py = $pzi[$tk]
        })
    }

    if ($DebugEventTrace.IsPresent) {
        $secMaxGas = ($gas[$k0..$k1] | Measure-Object -Maximum).Maximum
        $secMaxBrk = ($brk[$k0..$k1] | Measure-Object -Maximum).Maximum
        [void]$debugRows.Add([pscustomobject]@{
            Phase = 'sector'
            Sector = ('T{0}' -f ($ti + 1))
            k0 = $k0
            k1 = $k1
            searchBrakeK0 = $searchK0
            bk = $bk
            brkEnd = $brkEnd
            gasSearchK0 = $gasSearchK0
            tkRise = $tkRise
            tkSustain = $tkSustain
            tkReapply = $tkReapply
            tkPicked = $tk
            tkSource = $tkSource
            secMaxGas = $secMaxGas
            secMaxBrk = $secMaxBrk
        })
    }
}

$markerId = 0
$orderedEvents = @($events | Sort-Object K, Kind)

# Global补漏：若两次刹车之间无油门点，则在中间区间再做一次补油搜索。
$brakeEvents = @($orderedEvents | Where-Object { $_.Kind -eq 'brake' } | Sort-Object K)
if ($brakeEvents.Count -ge 2) {
    for ($bi = 0; $bi -lt $brakeEvents.Count - 1; $bi++) {
        $kA = [int]$brakeEvents[$bi].K
        $kB = [int]$brakeEvents[$bi + 1].K
        if (($kB - $kA) -lt 3) { continue }

        $hasGasBetween = $false
        foreach ($ev2 in $orderedEvents) {
            if ($ev2.Kind -eq 'gas' -and $ev2.K -gt $kA -and $ev2.K -lt $kB) {
                $hasGasBetween = $true
                break
            }
        }
        if ($hasGasBetween) { continue }

        $g0 = $kA + 1
        $g1 = $kB - 1
        $tkMid = Find-FirstRisingSustainedAbove $gas $g0 $g1 $GasPedalThreshold $gasFrames
        if ($tkMid -lt 0) {
            $tkMid = Find-FirstSustainedAbove $gas $g0 $g1 $GasPedalThreshold $gasFrames
        }
        if ($tkMid -lt 0) {
            $tkMid = Find-FirstGasReapply $gas $brk $g0 $g1 $GasReapplyThreshold $GasReapplyDelta $GasReapplyBrakeMax $gasReapplyFrames
        }
        if ($tkMid -lt 0 -and $AllowOverlapThrottleBetweenBrakes) {
            # Only in brake-to-brake gaps: allow overlap throttle reapply without brake-max constraint.
            $tkMid = Find-FirstGasReapplyOverlap $gas $g0 $g1 $GasReapplyThreshold $GasReapplyDelta $gasReapplyFrames
            if ($tkMid -lt 0) {
                # If gas is already high in this gap (no rise edge), capture the first sustained high-gas sample.
                $tkMid = Find-FirstSustainedAbove $gas $g0 $g1 $GasReapplyThreshold $gasReapplyFrames
            }
            if ($tkMid -lt 0) {
                # Final fallback for brake-to-brake gap: pick max-gas point in gap to avoid missing obvious refill.
                $bestK = -1
                $bestG = -1
                for ($kk = $g0; $kk -le $g1; $kk++) {
                    if ($gas[$kk] -gt $bestG) { $bestG = $gas[$kk]; $bestK = $kk }
                }
                if ($bestG -ge $GasReapplyThreshold) { $tkMid = $bestK }
            }
        }
        if ($DebugEventTrace.IsPresent) {
            [void]$debugRows.Add([pscustomobject]@{
                Phase = 'global_gap_probe'
                Sector = ('T{0}->T{1}' -f $brakeEvents[$bi].Sector, $brakeEvents[$bi + 1].Sector)
                k0 = $g0
                k1 = $g1
                searchBrakeK0 = ''
                bk = $kA
                brkEnd = $kB
                gasSearchK0 = $g0
                tkRise = ''
                tkSustain = ''
                tkReapply = ''
                tkPicked = $tkMid
                tkSource = if ($tkMid -ge 0) { 'global_probe_hit' } else { 'global_probe_miss' }
                secMaxGas = ($gas[$g0..$g1] | Measure-Object -Maximum).Maximum
                secMaxBrk = ($brk[$g0..$g1] | Measure-Object -Maximum).Maximum
            })
        }
        if ($tkMid -ge 0) {
            [void]$events.Add([pscustomobject]@{
                K = $tkMid
                Kind = 'gas'
                Sector = 0
                Source = 'global_gap_fill_overlap_ok'
                GasValue = [int]$gas[$tkMid]
                Speed = [int][math]::Round($sp[$tkMid], 0)
                Px = $pxi[$tkMid]
                Py = $pzi[$tkMid]
            })
            if ($DebugEventTrace.IsPresent) {
                [void]$debugRows.Add([pscustomobject]@{
                    Phase = 'global_gap_fill'
                    Sector = ('T{0}->T{1}' -f $brakeEvents[$bi].Sector, $brakeEvents[$bi + 1].Sector)
                    k0 = $g0
                    k1 = $g1
                    searchBrakeK0 = ''
                    bk = $brakeEvents[$bi].K
                    brkEnd = $brakeEvents[$bi + 1].K
                    gasSearchK0 = $g0
                    tkRise = ''
                    tkSustain = ''
                    tkReapply = ''
                    tkPicked = $tkMid
                    tkSource = 'global_gap_fill'
                    secMaxGas = ($gas[$g0..$g1] | Measure-Object -Maximum).Maximum
                    secMaxBrk = ($brk[$g0..$g1] | Measure-Object -Maximum).Maximum
                })
            }
        }
    }
    $orderedEvents = @($events | Sort-Object K, Kind)
}

# Second-pass robust补漏（仅连续刹车之间）:
# If a brake-to-brake gap still has no gas marker, insert one at max-gas position in that gap.
if ($AllowOverlapThrottleBetweenBrakes) {
    $orderedEvents = @($events | Sort-Object K, Kind)
    $brakeEvents2 = @($orderedEvents | Where-Object { $_.Kind -eq 'brake' } | Sort-Object K)
    if ($brakeEvents2.Count -ge 2) {
        for ($bi2 = 0; $bi2 -lt $brakeEvents2.Count - 1; $bi2++) {
            $kA2 = [int]$brakeEvents2[$bi2].K
            $kB2 = [int]$brakeEvents2[$bi2 + 1].K
            if (($kB2 - $kA2) -lt 3) { continue }

            $hasGasBetween2 = $false
            foreach ($evx in $orderedEvents) {
                if ($evx.Kind -eq 'gas' -and $evx.K -gt $kA2 -and $evx.K -lt $kB2) {
                    $hasGasBetween2 = $true
                    break
                }
            }
            if ($hasGasBetween2) { continue }

            $g02 = $kA2 + 1
            $g12 = $kB2 - 1
            $bestK2 = -1
            $bestG2 = -1
            for ($kk2 = $g02; $kk2 -le $g12; $kk2++) {
                if ($gas[$kk2] -gt $bestG2) { $bestG2 = $gas[$kk2]; $bestK2 = $kk2 }
            }
            if ($bestK2 -ge 0 -and $bestG2 -ge $GasReapplyThreshold) {
                [void]$events.Add([pscustomobject]@{
                    K = $bestK2
                    Kind = 'gas'
                    Sector = 0
                    Source = 'global_gap_force_max'
                    GasValue = [int]$gas[$bestK2]
                    Speed = [int][math]::Round($sp[$bestK2], 0)
                    Px = $pxi[$bestK2]
                    Py = $pzi[$bestK2]
                })
            }
        }
        $orderedEvents = @($events | Sort-Object K, Kind)
    }
}

# Rule: between two consecutive brake points, keep at most one gas point.
if ($orderedEvents.Count -gt 0) {
    $removeIdx = New-Object 'System.Collections.Generic.HashSet[int]'
    $brakeIdx = New-Object System.Collections.Generic.List[int]
    for ($i = 0; $i -lt $orderedEvents.Count; $i++) {
        if ($orderedEvents[$i].Kind -eq 'brake') { [void]$brakeIdx.Add($i) }
    }
    for ($bi3 = 0; $bi3 -lt $brakeIdx.Count - 1; $bi3++) {
        $ia = $brakeIdx[$bi3]
        $ib = $brakeIdx[$bi3 + 1]
        $gasCandidates = New-Object System.Collections.Generic.List[int]
        for ($i = $ia + 1; $i -lt $ib; $i++) {
            if ($orderedEvents[$i].Kind -eq 'gas') { [void]$gasCandidates.Add($i) }
        }
        if ($gasCandidates.Count -le 1) { continue }
        # Keep earliest gas marker between two brake markers.
        $keep = $gasCandidates | Sort-Object { [int]$orderedEvents[$_].K } | Select-Object -First 1
        foreach ($gi in $gasCandidates) {
            if ($gi -ne $keep) { [void]$removeIdx.Add([int]$gi) }
        }
    }
    if ($removeIdx.Count -gt 0) {
        $filtered = New-Object System.Collections.Generic.List[object]
        for ($i = 0; $i -lt $orderedEvents.Count; $i++) {
            if (-not $removeIdx.Contains($i)) { [void]$filtered.Add($orderedEvents[$i]) }
        }
        $orderedEvents = $filtered.ToArray()
    }
}

foreach ($ev in $orderedEvents) {
    $markerId++
    $lbl = ('A{0} {1} km/h' -f $markerId, $ev.Speed)
    if ($ev.Kind -eq 'brake') {
        $pl = New-LabelPlacement $g $fontMk $lbl $ev.Px $ev.Py $bmpW $bmpH $occupied $bOff
        $g.FillEllipse($brushRed, $ev.Px - 7, $ev.Py - 7, 14, 14)
    } else {
        $pl = New-LabelPlacement $g $fontMk $lbl $ev.Px $ev.Py $bmpW $bmpH $occupied $gOff
        $g.FillEllipse($brushGreen, $ev.Px - 7, $ev.Py - 7, 14, 14)
    }
    Draw-StringWithLeader $g $fontMk $brushTxt $penLeader $ev.Px $ev.Py $lbl $pl
}

if ($DebugEventTrace.IsPresent) {
    $aRows = New-Object System.Collections.Generic.List[object]
    $aId = 0
    foreach ($ev in $orderedEvents) {
        $aId++
        [void]$aRows.Add([pscustomobject]@{
            Phase = 'A_sequence'
            Sector = if ($ev.Sector -gt 0) { 'T' + $ev.Sector } else { '-' }
            A = 'A' + $aId
            Kind = $ev.Kind
            Source = $ev.Source
            K = $ev.K
            AbsFrame = $idx[$ev.K]
            ArcS_m = [Math]::Round($s[$ev.K], 3)
            Speed_kmh = $ev.Speed
        })
    }

    $gapRows = New-Object System.Collections.Generic.List[object]
    $brOnly = @($aRows | Where-Object { $_.Kind -eq 'brake' })
    for ($gi = 0; $gi -lt $brOnly.Count - 1; $gi++) {
        $a = $brOnly[$gi]
        $b = $brOnly[$gi + 1]
        $ka = [int]$a.K; $kb = [int]$b.K
        if (($kb - $ka) -lt 2) { continue }
        $lo = $ka + 1; $hi = $kb - 1
        $hasGas = ($aRows | Where-Object { $_.Kind -eq 'gas' -and [int]$_.K -gt $ka -and [int]$_.K -lt $kb } | Select-Object -First 1)
        $maxGas = ($gas[$lo..$hi] | Measure-Object -Maximum).Maximum
        $maxBrk = ($brk[$lo..$hi] | Measure-Object -Maximum).Maximum
        $run180 = Get-LongestRunAbove $gas $lo $hi 180
        $run60 = Get-LongestRunAbove $gas $lo $hi 60
        $run40 = Get-LongestRunAbove $gas $lo $hi 40
        [void]$gapRows.Add([pscustomobject]@{
            Phase = 'brake_gap'
            Sector = ($a.A + '->' + $b.A)
            A = ''
            Kind = ''
            Source = if ($hasGas) { 'has_gas' } else { ("no_gas(run180={0},run60={1},run40={2})" -f $run180, $run60, $run40) }
            K = "$lo..$hi"
            AbsFrame = "$($idx[$lo])..$($idx[$hi])"
            ArcS_m = [Math]::Round(($s[$lo] + $s[$hi]) / 2.0, 3)
            Speed_kmh = ''
            MaxGas = $maxGas
            MaxBrake = $maxBrk
        })
    }

    $all = @($debugRows + $aRows + $gapRows) | ForEach-Object {
        [pscustomobject]@{
            Phase = if ($_.PSObject.Properties.Name -contains 'Phase') { $_.Phase } else { '' }
            Sector = if ($_.PSObject.Properties.Name -contains 'Sector') { $_.Sector } else { '' }
            A = if ($_.PSObject.Properties.Name -contains 'A') { $_.A } else { '' }
            Kind = if ($_.PSObject.Properties.Name -contains 'Kind') { $_.Kind } else { '' }
            Source = if ($_.PSObject.Properties.Name -contains 'Source') { $_.Source } else { '' }
            K = if ($_.PSObject.Properties.Name -contains 'K') { $_.K } else { '' }
            AbsFrame = if ($_.PSObject.Properties.Name -contains 'AbsFrame') { $_.AbsFrame } else { '' }
            ArcS_m = if ($_.PSObject.Properties.Name -contains 'ArcS_m') { $_.ArcS_m } else { '' }
            Speed_kmh = if ($_.PSObject.Properties.Name -contains 'Speed_kmh') { $_.Speed_kmh } else { '' }
            MaxGas = if ($_.PSObject.Properties.Name -contains 'MaxGas') { $_.MaxGas } else { '' }
            MaxBrake = if ($_.PSObject.Properties.Name -contains 'MaxBrake') { $_.MaxBrake } else { '' }
            k0 = if ($_.PSObject.Properties.Name -contains 'k0') { $_.k0 } else { '' }
            k1 = if ($_.PSObject.Properties.Name -contains 'k1') { $_.k1 } else { '' }
            searchBrakeK0 = if ($_.PSObject.Properties.Name -contains 'searchBrakeK0') { $_.searchBrakeK0 } else { '' }
            bk = if ($_.PSObject.Properties.Name -contains 'bk') { $_.bk } else { '' }
            brkEnd = if ($_.PSObject.Properties.Name -contains 'brkEnd') { $_.brkEnd } else { '' }
            gasSearchK0 = if ($_.PSObject.Properties.Name -contains 'gasSearchK0') { $_.gasSearchK0 } else { '' }
            tkRise = if ($_.PSObject.Properties.Name -contains 'tkRise') { $_.tkRise } else { '' }
            tkSustain = if ($_.PSObject.Properties.Name -contains 'tkSustain') { $_.tkSustain } else { '' }
            tkReapply = if ($_.PSObject.Properties.Name -contains 'tkReapply') { $_.tkReapply } else { '' }
            tkPicked = if ($_.PSObject.Properties.Name -contains 'tkPicked') { $_.tkPicked } else { '' }
            tkSource = if ($_.PSObject.Properties.Name -contains 'tkSource') { $_.tkSource } else { '' }
            secMaxGas = if ($_.PSObject.Properties.Name -contains 'secMaxGas') { $_.secMaxGas } else { '' }
            secMaxBrk = if ($_.PSObject.Properties.Name -contains 'secMaxBrk') { $_.secMaxBrk } else { '' }
        }
    }
    $all | Export-Csv -LiteralPath $DebugOutputPath -NoTypeInformation -Encoding UTF8
    $a1415 = $gapRows | Where-Object { $_.Sector -eq 'A14->A15' } | Select-Object -First 1
    if ($null -ne $a1415) {
        Write-Host ("Debug A14->A15: source={0} maxGas={1} maxBrake={2} gapK={3}" -f $a1415.Source, $a1415.MaxGas, $a1415.MaxBrake, $a1415.K)
    }
    Write-Host "Debug trace saved: $DebugOutputPath"
}

$sub = ('dt={0}ms brake>={1}s thr={2} gas>={3} expand={4}m' -f [int]($dt * 1000), $BrakeMinSeconds, $ThrottleMinSeconds, $GasPedalThreshold, $SectorExpandMeters)
$title = $cap.titlePrefix + '  Lap=' + $Lap + '  L=' + [math]::Round($lapLen, 0) + 'm  ' + $sub + '  ' + (Get-Date -Format 'yyyy-MM-dd HH:mm')
$g.DrawString($title, $fontTitle, $brushTxt, 10.0, 8.0)
$leg = $cap.legend + '  |  ' + $sub
$g.DrawString($leg, $fontMk, $brushTxt, 10.0, [float]($bmpH - 42))

$bmp.Save($OutputPath, [System.Drawing.Imaging.ImageFormat]::Png)
$g.Dispose(); $bmp.Dispose()
$penTrace.Dispose(); $penLeader.Dispose()
$brushRed.Dispose(); $brushGreen.Dispose(); $brushTxt.Dispose(); $brushSf.Dispose()
$fontTitle.Dispose(); $fontMk.Dispose()
Write-Host "Saved: $OutputPath"

打包exe

没想到打包exe，这个简单的需求反而是最麻烦的，最难处理的。

AI生成的都是powershell的脚本，我想把它打包成一个exe，可以方便使用一些。

打包 exe 重写了三遍，第一遍打包 exe 还要调用脚本，那这个 exe 的意义何在；第二遍打包各种路径弄不对；第三遍打包增加测试方法以后，总算给出来一个能用的 exe 了。

#Requires -Version 5.1
# 将 BuildIdealLineFromReplay.ps1 / DrawZhuhaiLapCorners.ps1 打成 exe。
# 先输出到 %TEMP% 再复制到 tools，避免目标 exe 被占用时 PS2EXE 无法删除旧文件导致打包失败。
$ErrorActionPreference = 'Stop'
$here = $PSScriptRoot
Import-Module (Join-Path $here 'ps2exe-module\ps2exe.psd1') -Force

function Stop-ToolProcess([string]$exeFileName) {
    $base = [IO.Path]::GetFileNameWithoutExtension($exeFileName)
    Get-Process -Name $base -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue
}

function Copy-ExeToTools {
    param([string]$TempExe, [string]$DestExe)
    Copy-Item -LiteralPath $TempExe -Destination $DestExe -Force
}

$targets = @(
    @{ In = 'BuildIdealLineFromReplay.ps1'; Out = 'BuildIdealLineFromReplay.exe'; Title = 'BuildIdealLineFromReplay'; ConHost = $true },
    @{ In = 'DrawZhuhaiLapCorners.ps1'; Out = 'DrawZhuhaiLapCorners.exe'; Title = 'DrawZhuhaiLapCorners'; ConHost = $false }
)
foreach ($t in $targets) {
    $inPath = Join-Path $here $t.In
    $outPath = Join-Path $here $t.Out
    Write-Host "Building $outPath ..."
    Stop-ToolProcess $t.Out
    Start-Sleep -Milliseconds 400
    $tmp = Join-Path $env:TEMP ('ps2exe_' + [guid]::NewGuid().ToString('N') + '_' + $t.Out)
    try {
        # Draw：System.Drawing 用 -STA；-conHost 会导致脚本未跑完、PNG 不落盘。
        # BuildIdealLine：-conHost 便于无控制台/部分自动化场景结束等待。
        if ($t.ConHost) {
            Invoke-ps2exe -inputFile $inPath -outputFile $tmp -conHost -title $t.Title
        } else {
            Invoke-ps2exe -inputFile $inPath -outputFile $tmp -STA -noConsole:$false -title $t.Title
        }
        Copy-ExeToTools -TempExe $tmp -DestExe $outPath
        Write-Host "  -> $outPath"
    } finally {
        Remove-Item -LiteralPath $tmp -Force -ErrorAction SilentlyContinue
    }
}
Write-Host 'Done.'

Summary

最终生成的代码如下，也一起打包了exe

https://github.com/elmagnificogi/ACRecord2AILine.git

对于AI来完成一个项目一些前提：

项目是否可行，前期需要一些验证性的方案摸底，确定技术方案是否可行，以及AI使用何种方案进行
需求需要明确，越细致越好
AI生成的结果需要有基础的测试用例，能量化到具体数值、行为、结果最好，图片化的结果比较麻烦需要人工反馈，给AI自己识别还是存在一定误差的
建议最好把需求点拆成一个阶段一个阶段的，每一步都完成验证以后再进行下一步，而不是一个总体目标和测试结果，会导致AI自己卡在其中反复迭代，无限消耗token，还得不到要的结果
- 这一点要着重强调，实际上Cursor有200K的上下文，而AI一旦陷入其中就会出现上下文不够用的情况，继而导致核心需求或者描述的上下文被丢失，AI进入恶性循环中，再也出不去

再完成转exe和画分析图的过程中都出现了上下文不够用的情况，我只好重新总结要求，新开一个agent再次进行，而这样再次进行的上下文大概只用了1/3就完成了所有新工作

当AI出现试错或者走向错误分支的时候，这部分上下文可能会占用很多tokens消耗，最好人工发现以后，简单总结，避免再走向错误的道路中

一共就写这么不到 2000 行的代码，2 个需求 + 一个 CI 打包，去掉我 4 月前几天的消耗，大概 400 万 tokens，完成这个消耗了 5400 万 tokens，这里面有很多 cache，但是总体量就得有这么多，平均一行代码消耗 2 万多 tokens，还是很恐怖的。

这么一个需求消耗了接近1/3的Cursor用量，核算下来大概是5刀，30来块钱，看起来挺少的，但是总共耗时大概是7-8小时，是我全程辅助以后的结果。

如果给我7-8小时，纯工作时间，估计也能做到差不多的程度，但是消耗的脑力就很多了，我需要从头开始学习和实验。

后续如果再用AI做需求，再完善一下方法论，再给到AI应该会更快更好一些。