feat(c-core): 内核编解码层 C 化第一刀 —— L1 纯函数层落地并打通构建链

第一刀只做三个纯函数（窗口推断 / token 估算 / token 截断），
价值不在功能（Go 版没问题），而在打通「Go → cgo → C」全链路并
建立可复现的对照范式，后面每扩一个函数都复用它。

## 为什么是这三个

按「无状态 → 有状态」分层，L1 协议编解码最安全：纯 string in → struct out，
不碰网络、不碰 Lua、不碰 goroutine。三个函数更是同一组纯算术，最小可验证切片。

## 关键设计：包内符号链接，不链接静态库、不 include 包外源

三种做法都实测过，只有一种同时满足「可构建 + 可交叉编译 + 缓存可跟踪」：

1. ❌ 链接 `csrc/build/libha_codec.a`（原方案）
   - .a 是构建产物、不入库（.gitignore 的 build/ 命中 csrc/build/），
     而发布脚本原先并不产出它 ⇒「不入库 + 不生成」两头空，
     实测报 `cannot find .../libha_codec.a`
   - 交叉编译 linux/arm64（homed 真实发布目标）时，宿主 x86-64 的 .a
     被链进目标产物，实测报 `file in wrong format`

2. ❌ `#include "../../../csrc/src/ha_codec.c"`（包外相对包含）
   ★ Go 构建缓存**不跟踪包外被 #include 的 C 文件**。实测：包外源把返回值
   7→8，`go test` 依然通过（缓存命中、静默沿用旧代码）；同样改动落在包内
   文件时立即判红。对「逐步推进 C 化」这是致命的——改 C 源码不生效且无报错。
   （包内 shim `#include` 包外源同样漏跟踪，已实测排除。）

3. ✅ 包内符号链接 `internal/agent/api/ha_codec.{c,h}` → `csrc/`
   文件在包目录内 ⇒ 缓存按内容正确跟踪；只有一份权威源 ⇒ 无副本漂移，
   也不需要「同步 C 源」的 make 目标。

## 不需要额外 build tag

ha_codec 是零依赖纯 C99 源码内联编译，不需要外部库或工具链前提；
而 homed 本就强制 cgo（sqlite3 + gojieba），故 C 路径自然生效。
只用 `cgo` / `!cgo` 一组约束（对比 onnxruntime：那个需运行期 .so，故必须显式 tag）。

## 顺带修掉的既有缺陷（非 C 化引入，但一直缺覆盖）

- Makefile 的 arm64 目标缺 CC/CXX：cgo 回退到宿主 g++，报
  `gcc_arm64.S: no such instruction: 'stp x29,x30,[sp,'`
  （deploy/packaging/build.sh:49 一直是对的，Makefile 漏了）
- Makefile 的 arm64 目标缺 .syso 隔离：cmd/{homed,waiter}/*.syso 是 Windows
  COFF 资源对象，Go 会把同目录 .syso 无条件链进任何目标，交叉到非 Windows
  平台报 `file format not recognized`（build.sh 有 hide_syso_for_target）

## 验证（每条可复现）

- `make build-linux-arm64` → ELF 64-bit LSB executable, ARM aarch64（82MB）
- `bash deploy/packaging/build.sh linux/arm64 homed` → ELF aarch64（79MB）
- 移走 csrc/build/ 后 homed（cgo）与 waiter（CGO=0）均能构建
- 变异 C 源（131072→777）后**同一缓存**下 go test 立即 FAIL（改前：仍报 ok）
- `make check-codec-paths` 两条路径 OK；`make csrc-test` C 契约测试 100%
- 黄金对照：手写用例 + 2000 次随机对拍，C 与纯 Go 逐值相等
- 全量 `go test -count=1 ./...` → 57 包：38 ok + 19 无测试 + 0 FAIL

新增 `make check-codec-paths` 防回归：只测一条路径时，另一条的破坏不会被发现。

## 文档

- `docs/zh/c-core/llm-orchestration-c.md` 同步为「已落地」，并更正因
  「Windows 原生已放弃」而过时的 §2.3（回退路径的理由需重述）
- plan.md 的 P0-1 标记为已修复，附实测证据

csrc/src/ha_codec.c

@@ -0,0 +1,191 @@
+/*
+ * ha_codec.c — HomeAgent 内核编解码层（C 实现）
+ *
+ * 第一个最小切片：模型窗口推断 + token 估算/截断。
+ * 语义必须与 Go 侧实现逐值一致，由黄金对照测试钉死。
+ */
+
+#include "ha_codec.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ---------------------------------------------------------------- */
+/* 小工具                                                            */
+/* ---------------------------------------------------------------- */
+
+/* 在 s 中查找子串 sub（子串已小写）。s 需已是小写。找不到返回 NULL。 */
+static const char *find_sub(const char *s, const char *sub) {
+    return strstr(s, sub);
+}
+
+/* 分配一份小写副本。调用方负责 free。失败返回 NULL。 */
+static char *lower_dup(const char *s) {
+    if (s == NULL) {
+        return NULL;
+    }
+    size_t n = strlen(s);
+    char *p = (char *)malloc(n + 1);
+    if (p == NULL) {
+        return NULL;
+    }
+    for (size_t i = 0; i < n; i++) {
+        /* 只对 ASCII 做小写；UTF-8 多字节原样保留（与 Go strings.ToLower 对
+         * 中文不改变结果一致——Go 会把非 ASCII 也处理，但模型名都是 ASCII）。 */
+        unsigned char c = (unsigned char)s[i];
+        p[i] = (char)((c < 0x80) ? tolower(c) : c);
+    }
+    p[n] = '\0';
+    return p;
+}
+
+/* ---------------------------------------------------------------- */
+/* 模型上下文窗口推断                                                */
+/* ---------------------------------------------------------------- */
+
+int ha_codec_model_context_window(const char *model) {
+    if (model == NULL) {
+        return HA_CODEC_CONTEXT_WINDOW_UNKNOWN;
+    }
+
+    char *m = lower_dup(model);
+    if (m == NULL) {
+        return HA_CODEC_CONTEXT_WINDOW_UNKNOWN;
+    }
+
+    int result = HA_CODEC_CONTEXT_WINDOW_UNKNOWN;
+
+    /* 顺序与 Go 侧 switch 分支**严格一致**：先匹配到的分支胜出。
+     * 这不是「随便一组 if」，顺序错了就会给出不同窗口。 */
+    if (find_sub(m, "deepseek-v4") || find_sub(m, "deepseek-v3")) {
+        result = 1048576;
+    } else if (find_sub(m, "deepseek-r1") || find_sub(m, "deepseek-chat")) {
+        result = 65536;
+    } else if (find_sub(m, "gpt-4") &&
+               (find_sub(m, "turbo") || find_sub(m, "mini") || find_sub(m, "omni"))) {
+        result = 128000;
+    } else if (find_sub(m, "gpt-4")) {
+        result = 8192;
+    } else if (find_sub(m, "gpt-3.5")) {
+        result = 16384;
+    } else if (find_sub(m, "claude-3.5") || find_sub(m, "claude-3")) {
+        result = 200000;
+    } else if (find_sub(m, "claude")) {
+        result = 100000;
+    } else if (find_sub(m, "gemini-1.5") || find_sub(m, "gemini-2")) {
+        result = 1048576;
+    } else if (find_sub(m, "gemini")) {
+        result = 32768;
+    } else if (find_sub(m, "qwen")) {
+        result = 131072;
+    } else if (find_sub(m, "glm") || find_sub(m, "chatglm")) {
+        result = 131072;
+    } else if (find_sub(m, "llama-3")) {
+        result = 8192;
+    } else if (find_sub(m, "llama-2")) {
+        result = 4096;
+    } else if (find_sub(m, "mistral") || find_sub(m, "mixtral")) {
+        result = 32768;
+    } else if (find_sub(m, "yi-") || find_sub(m, "零一")) {
+        result = 200000;
+    } else if (find_sub(m, "moonshot") || find_sub(m, "kimi")) {
+        result = 131072;
+    }
+
+    free(m);
+    return result;
+}
+
+/* ---------------------------------------------------------------- */
+/* token 估算                                                        */
+/* ---------------------------------------------------------------- */
+
+/* 计 UTF-8 字符数（rune 数）并返回下一字符起点。
+ * 非法字节按 1 字符前进（不吞字节），保证不会死循环。 */
+static size_t utf8_next(const char *s, size_t remaining) {
+    unsigned char c = (unsigned char)s[0];
+    size_t len = 1;
+    if (c >= 0xF0 && remaining >= 4) {
+        len = 4;
+    } else if (c >= 0xE0 && remaining >= 3) {
+        len = 3;
+    } else if (c >= 0xC0 && remaining >= 2) {
+        len = 2;
+    }
+    return len;
+}
+
+int ha_codec_estimate_tokens(const char *text) {
+    if (text == NULL || text[0] == '\0') {
+        return 0;
+    }
+
+    size_t n = strlen(text);
+    size_t runes = 0;
+    size_t i = 0;
+    while (i < n) {
+        i += utf8_next(text + i, n - i);
+        runes++;
+    }
+
+    /* 与 Go 侧一致：t = runeCount * 2；t < 1 时取 1。
+     * runes > 0 时 t >= 2，故只需处理溢出与下限。 */
+    if (runes > (size_t)0x3FFFFFFF) { /* 防 int 溢出 */
+        return 0x7FFFFFFF;
+    }
+    int t = (int)(runes * 2);
+    if (t < 1) {
+        return 1;
+    }
+    return t;
+}
+
+/* ---------------------------------------------------------------- */
+/* 按 token 截断                                                     */
+/* ---------------------------------------------------------------- */
+
+size_t ha_codec_truncate_by_tokens(const char *text, int max_tokens,
+                                   char *out, size_t out_cap) {
+    if (out == NULL || out_cap == 0) {
+        return 0;
+    }
+    out[0] = '\0';
+
+    if (max_tokens <= 0 || text == NULL || text[0] == '\0') {
+        return 0;
+    }
+
+    size_t n = strlen(text);
+
+    /* 先算 rune 数：与 Go 侧 len([]rune(s))*2 <= maxTokens 的短路一致 */
+    size_t runes = 0;
+    size_t i = 0;
+    while (i < n) {
+        i += utf8_next(text + i, n - i);
+        runes++;
+    }
+
+    /* 未超限：整体返回 */
+    if (runes <= (size_t)0x3FFFFFFF && (int)(runes * 2) <= max_tokens) {
+        size_t copy = (n < out_cap - 1) ? n : (out_cap - 1);
+        memcpy(out, text, copy);
+        out[copy] = '\0';
+        return copy;
+    }
+
+    /* 保留 maxTokens/2 个字符（与 Go 一致：keep := maxTokens / 2，整数除法） */
+    size_t keep = (size_t)(max_tokens / 2);
+
+    size_t byte_end = 0;
+    size_t kept = 0;
+    while (kept < keep && byte_end < n) {
+        byte_end += utf8_next(text + byte_end, n - byte_end);
+        kept++;
+    }
+
+    size_t copy = (byte_end < out_cap - 1) ? byte_end : (out_cap - 1);
+    memcpy(out, text, copy);
+    out[copy] = '\0';
+    return copy;
+}