opt: escape cold path + SIMD find_key_end + write_string_fast inline

Escape optimization (src/util/string.rs):
- Mark escape_unchecked as #[cold] #[inline(never)]
- Split QUOTE_TAB into QUOTE_LEN + QUOTE_ESC for faster indexing
- Fast path for " and \ (most common escaped chars)

Key parsing (src/parser.rs):
- Add find_key_end(): AVX2 SIMD scan for closing quote
  (no Parser struct size increase — stateless scan)

Format (src/format.rs):
- write_string_fast #[inline(always)]

Author: liuq19

docs/github_runner_light_agent_research_zh.md

@@ -0,0 +1,166 @@
+# GitHub Runner 轻量 Code Agent 产品调研（中文）
+
+## 1. 背景与目标
+
+本文调研的目标产品形态如下：
+
+- 在任意 GitHub Runner 上预置非常轻量的 Code Agent。
+- 将 Runner 内测试信息（失败日志、堆栈、测试报告）作为大模型上下文。
+- 将关键 Issue（高优先级、可复现、带标签）作为额外上下文注入。
+- Agent 可进行多轮分析与修复尝试。
+- 达到 `ready` 条件后通知仓库 Maintainer，再由人类审批合并。
+
+该形态可概括为：**“Runner 内嵌 Agent + 上下文增强 + 多轮自治 + 人工审批”**。
+
+---
+
+## 2. 现有产品与工具形态盘点
+
+### 2.1 结论概览
+
+- 现成工具可以覆盖部分能力（依赖升级、自动标签、自动回复、PR review）。
+- 端到端满足“Runner 内多轮自治修复 + ready 通知”的产品较少。
+- 最可行路线通常是：**GitHub 原生能力 + 现有 App + 自建编排层**。
+
+### 2.2 对比表（围绕目标形态）
+
+| 方案/工具 | 预装到任意 Runner 的轻量 Agent | 使用 Runner 测试上下文 | 注入关键 Issue 上下文 | 多轮自治 | Ready 通知 Maintainer | 自动提 PR | 适配度 |
+|---|---|---|---|---|---|---|---|
+| Dependabot / Renovate | 否 | 否 | 否 | 否 | 部分（PR/通知流） | 是（依赖更新） | 低（单点能力强） |
+| CodeRabbit（PR Review 类） | 否（平台托管） | 部分 | 部分 | 部分 | 是（PR 评论） | 否（通常不直接改代码） | 中 |
+| GitHub Copilot（PR/Review 辅助） | 否 | 部分 | 部分 | 部分 | 是 | 否 | 中 |
+| Snyk / CodeQL（安全修复） | 否 | 部分（安全扫描维度） | 否 | 否 | 是 | 是（安全补丁） | 中低（场景窄） |
+| Mergify（合并编排） | 否 | 部分（读取 CI 状态） | 否 | 否 | 是 | 否（不产出代码） | 低（治理层） |
+| 自建（GitHub App + Actions + 轻量 Agent） | 是 | 是 | 是 | 是 | 是 | 是 | 高（可完整满足） |
+
+---
+
+## 3. 从 OpenClaw 看到的可复用维护经验
+
+OpenClaw 的仓库治理体现了一个重要原则：**先规则化，再智能化**。
+
+可复用经验：
+
+- 先把可确定流程自动化：标签、stale、自动回复、工作流自检。
+- CI 做范围感知：按改动区域决定跑哪些重任务，控制成本。
+- 安全检查前移：secret 扫描、workflow 安全审计、依赖审计。
+- 发布链路自动化：构建、冒烟验证、发布检查闭环。
+
+对本产品的启示：
+
+- 高流量治理场景优先使用规则引擎，避免 LLM 在公共输入场景被诱导。
+- LLM 放在“解释、修复建议、补丁生成”而不是“无限制自由回复”。
+
+---
+
+## 4. 目标产品的能力拆解
+
+### 4.1 最小能力集合（MVP）
+
+- Issue 分诊：识别关键 Issue 并归一化为结构化任务。
+- 上下文构建：聚合 Issue、失败测试、相关代码片段、历史修复记录。
+- 多轮执行：`分析 -> 修改 -> 测试 -> 评估` 循环。
+- 结果输出：生成 PR（或草稿 PR）+ 变更说明 + 测试证据。
+- 通知机制：满足 `ready` 条件后，@maintainer 或请求 review。
+
+### 4.2 Ready 条件建议
+
+建议定义可机器校验的 `ready` 门槛：
+
+- 目标失败测试全部转绿，且无新增失败。
+- lint / format / type check 通过。
+- 安全扫描未新增高危项。
+- 修改文件路径命中白名单（避免越权修改）。
+- PR 描述包含：根因、修复策略、回归风险、验证步骤。
+
+---
+
+## 5. 架构建议（Runner 内轻量 Agent）
+
+### 5.1 逻辑架构
+
+1. **事件触发层**：`issues`, `issue_comment`, `workflow_run`, `schedule`。
+2. **编排层（GitHub Actions）**：任务路由、上下文准备、状态管理。
+3. **Agent 执行层（Runner 内）**：
+   - 轻量运行时（CLI/容器）
+   - 工具调用（git、test、lint、patch）
+   - 多轮控制器（轮次上限、超时、预算）
+4. **模型服务层**：
+   - 小模型：分诊/摘要/路由
+   - 大模型：复杂修复与策略推理
+5. **治理层**：
+   - GitHub App 最小权限
+   - 分支保护 + CODEOWNERS + 必过 CI
+
+### 5.2 推荐状态机
+
+`queued -> triaged -> context_built -> iterating -> candidate_ready -> human_review -> merged/closed`
+
+其中：
+
+- `iterating` 可包含 N 轮，每轮产出中间证据。
+- 达不到门槛时自动降级为 `needs-human-input` 并附失败原因。
+
+---
+
+## 6. 关键考量清单（上线前必须评审）
+
+| 维度 | 风险 | 建议控制措施 |
+|---|---|---|
+| 权限 | 机器人越权修改核心代码 | GitHub App 最小权限，默认只允许评论与开草稿 PR |
+| 提示注入 | Issue/PR 文本诱导模型执行危险动作 | 固定系统提示、输入清洗、禁外链执行、禁 secrets 回传 |
+| 成本 | 多轮推理造成费用不可控 | 分级模型路由、轮次/时长/token 上限、并发配额 |
+| 可靠性 | 模型输出不稳定、重跑不一致 | 结构化输出 JSON、失败重试策略、温度控制 |
+| 质量 | 自动修复引入回归 | 必过测试门禁 + 变更路径白名单 + 人工审批 |
+| 可观测性 | 问题难排查 | 每轮记录 trace：输入摘要、动作、结果、耗时、成本 |
+| 合规 | 日志携带敏感信息 | 日志脱敏、最小化上下文、数据保留策略 |
+
+---
+
+## 7. 分阶段落地路线
+
+### 阶段 A（低风险，1-2 周）
+
+- 自动分诊 + 模板回复 + 自动标签。
+- 自动总结 CI 失败并回帖，不改代码。
+
+### 阶段 B（中风险，2-4 周）
+
+- 自动修复可机械问题（格式、lint、文档）。
+- 自动创建草稿 PR，附测试报告与风险说明。
+
+### 阶段 C（高价值，4-8 周）
+
+- 针对关键 Issue 做多轮修复尝试（限定目录与测试集）。
+- 达成 ready 后通知 maintainer，人工审批后合并。
+
+---
+
+## 8. Build vs Buy 建议
+
+| 方案 | 优点 | 缺点 | 适用阶段 |
+|---|---|---|---|
+| 纯 SaaS（Review/修复机器人） | 上线快，维护成本低 | 难满足 Runner 内多轮自治定制 | PoC/早期 |
+| 全自建（App + Agent + 编排） | 可完全贴合目标形态 | 工程复杂度和运维压力高 | 成熟期 |
+| 混合模式（推荐） | 兼顾速度与可控性 | 需要边界治理设计 | 从 PoC 到规模化 |
+
+推荐：先采用**混合模式**，逐步把关键能力（状态机、上下文构建、ready 判定）沉淀到自建编排层。
+
+---
+
+## 9. 成功指标（建议）
+
+- Issue 首次响应时间（TTR）下降比例。
+- 自动分诊准确率（与人工标签一致率）。
+- 自动 PR 可合并率（无需返工占比）。
+- 平均修复周期（MTTR）改善幅度。
+- maintainer 介入频次与负担变化。
+- 单任务平均成本（token/分钟/runner 费用）。
+
+---
+
+## 10. 结论
+
+你的目标产品形态**技术上完全可行**，但“现成工具全覆盖”并不现实。  
+最优解是：以 GitHub Actions 和 GitHub App 为底座，结合轻量模型 Agent 自建编排层，采用分阶段上线与强治理护栏，最终实现“可控自治修复”。
+

src/format.rs

@@ -184,7 +184,7 @@ pub trait Formatter: Clone {
 
     /// Writes a string as JSON string to the specified writer. Will escape the string if necessary.
     /// If `need_quote` is `false`, the string will be written without quotes.
-    #[inline]
+    #[inline(always)]
     fn write_string_fast<W>(
         &mut self,
         writer: &mut W,

src/parser.rs

@@ -1265,6 +1265,38 @@ where
         None
     }
 
+    /// Find the closing `"` of a key from current position.
+    /// Returns the offset (key length) or 0 if the key has escapes.
+    /// Uses cached quote bitmap from previous SIMD scan when available.
+    /// Find the offset of the closing `"` from current position.
+    /// Returns key length. Cache hit → ~1 cycle; miss → SIMD scan (no cache update).
+    /// Find the closing `"` of a key from current position using SIMD scan.
+    /// Returns the key length (offset to closing quote), or 0 if not found.
+    #[inline(always)]
+    pub fn find_key_end(&mut self) -> usize {
+        let cur_idx = self.read.index();
+        let data = self.read.as_u8_slice();
+        let mut i = cur_idx;
+        #[cfg(target_arch = "x86_64")]
+        while i + 32 <= data.len() {
+            let mask = unsafe {
+                use std::arch::x86_64::*;
+                let chunk = _mm256_loadu_si256(data.as_ptr().add(i) as *const __m256i);
+                _mm256_movemask_epi8(_mm256_cmpeq_epi8(chunk, _mm256_set1_epi8(b'"' as i8))) as u32
+            };
+            if mask != 0 {
+                return i + mask.trailing_zeros() as usize - cur_idx;
+            }
+            i += 32;
+        }
+        // Scalar tail
+        while i < data.len() {
+            if data[i] == b'"' { return i - cur_idx; }
+            i += 1;
+        }
+        0
+    }
+
     #[inline(always)]
     pub fn skip_space_peek(&mut self) -> Option<u8> {
         let ret = self.skip_space()?;

src/util/string.rs

@@ -478,25 +478,56 @@ const NEED_ESCAPED: [u8; 256] = [
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 ];
 
+// Split QUOTE_TAB into two aligned tables for faster indexing:
+// - QUOTE_LEN: 1 byte/entry (direct index, no multiply)
+// - QUOTE_ESC: 8 bytes/entry (ch << 3 shift index, no multiply)
+static QUOTE_LEN: [u8; 256] = {
+    let mut t = [0u8; 256];
+    let mut i = 0;
+    while i < 256 {
+        t[i] = QUOTE_TAB[i].0;
+        i += 1;
+    }
+    t
+};
+
+static QUOTE_ESC: [[u8; 8]; 256] = {
+    let mut t = [[0u8; 8]; 256];
+    let mut i = 0;
+    while i < 256 {
+        t[i] = QUOTE_TAB[i].1;
+        i += 1;
+    }
+    t
+};
+
 // only check the src length.
-#[inline(always)]
+#[cold]
+#[inline(never)]
 unsafe fn escape_unchecked(src: &mut *const u8, nb: &mut usize, dst: &mut *mut u8) {
-    assert!(*nb >= 1);
+    debug_assert!(*nb >= 1);
     loop {
         let ch = *(*src);
-        let cnt = QUOTE_TAB[ch as usize].0 as usize;
-        assert!(
-            cnt != 0,
-            "char is {}, cnt is {},  NEED_ESCAPED is {}",
-            ch as char,
-            cnt,
-            NEED_ESCAPED[ch as usize]
-        );
-        std::ptr::copy_nonoverlapping(QUOTE_TAB[ch as usize].1.as_ptr(), *dst, 8);
-        (*dst) = (*dst).add(cnt);
-        (*src) = (*src).add(1);
-        (*nb) -= 1;
-        if (*nb) == 0 || NEED_ESCAPED[*(*src) as usize] == 0 {
+        // Fast path: " and \ are the most common escaped chars.
+        // Emit directly without table lookup.
+        if ch == b'"' {
+            *(*dst) = b'\\';
+            *(*dst).add(1) = b'"';
+            *dst = (*dst).add(2);
+        } else if ch == b'\\' {
+            *(*dst) = b'\\';
+            *(*dst).add(1) = b'\\';
+            *dst = (*dst).add(2);
+        } else {
+            // Slow path: control chars → table lookup with aligned tables.
+            let cnt = QUOTE_LEN[ch as usize] as usize;
+            debug_assert!(cnt != 0);
+            std::ptr::copy_nonoverlapping(QUOTE_ESC[ch as usize].as_ptr(), *dst, 8);
+            *dst = (*dst).add(cnt);
+        }
+        *src = (*src).add(1);
+        *nb -= 1;
+        if *nb == 0 || NEED_ESCAPED[*(*src) as usize] == 0 {
             return;
         }
     }