train.md

# SAMAI-8B 长程监督在线训练规范（train.md v4.5 · 完整操作手册）

> 项目：SAMAI-8B / Qwen3.5-9B 多模态智能体——监督者亲自执行的在线强化训练
> 血统：base(Qwen/Qwen3.5-9B) + m11_final + m12_r1 + R2..R8 + R11/R12 长窗课程 → 现役 adapter **m13_r10**（268 窗血统链 m13_r6→r7→r8→r9→r10）
> 目标：长程规划执行（≥100K token / ≥200 步）、搜码改码调试、playwright 长会话、computer use
> 训练范式：**监督者亲手执行每一步**——直发任务、盯轨迹、验收、建样、点火爆发训练。不出新题，用已备题源（lproj / GAIA / SWE-bench / OSWorld）。
> v3 变更：①全部关键脚本**完整内联**（新环境断点重建可逐段复制执行）②踩坑册压成速查表③资产位置表更新（一切可从 HF 双仓恢复）
> v4 变更：④CUDA 链三坑固化（#33 LD_LIBRARY_PATH 追加式+驱动库剥离 / #34 大包直取 / #37 验收前置），坑册扩至 40 条 ⑤zagent 修复点复核（上游化后仅剩 2 处）⑥hub 新签名/gzip 配对/GAIA gate 新坑入册
> v4.1 追加（M15 首轮实战）：坑 #41 -c 是总池非每槽（131072/parallel2=65536/槽 → 66K 请求 HTTP 400，长程必须 262144）+ #42 狂暴重试环截停换卷 + #43 信封 4KB 红线复核；§五 发题模板环境注记（实测 0 误调）
> v4.2 追加（M15 死环根治轮）：坑 #44 软指令对死环 Qwen 免疫（HARDWRAP/quota/HARDFIN ×3 实证，唯一硬解=stop+短上下文新卷+配额机制）/ #45 新版 zagent resp_raw=<think> 原文（旧 [reasoning] 提取器失效）多卷并发 thinking 错位→建样宁缺毋滥 / #46 新版 transformers AutoProcessor 不继承 chat_template→显式兜底；新增 §七甲 反死环窗三型（止损决策/早断换路/配额收束）与 build_replay M15 修正
> v4.3 追加（死环根治收官）：坑 #47 web 工具执行入口在 web_stream.go 非 agent.go / #48 环检测 sig 必须 json.Marshal 规范化+key=sourceLabel；§七甲 增补框架级硬约束（zagent 反环 guard 实战 6 连拦）；§十一 M15 判分终局刷新
> v4.4 追加（R8-R9 新容器复活轮）：坑 #49-#56 十条（旗标秒退/隧道僵死/CMake 驱动链/tar 缺件/transformers 与 peft 兼容/go 私仓鉴权/补丁器前进指针）+ §八甲 GGUF 手术借壳战术；公开弹药库 tchbcb/samai-9b 建仓
> v4.5 追加（R10-R12 长窗纪律轮）：坑 #57-#66 十条（hub 嵌套/日志判据误报/hfget 误报/quantize 语法/GGUF 类型表/占位符顺序/执行站点补闸/bash 长命令/旗标双前缀/长窗 OOM 梯子）；§三 zagent 修复点清零（PR#188/#189 已上游合并）；§四 信封 v=1 协议（aitun.cc GVMHKJCU 全套）；§七甲 增补 R10 终审（量化无罪/长上下文有罪）+ R11/R12 长窗课程（268 窗→m13_r10）；§十/§十一 战绩与状态刷新
> 日期：2026-09-24 | 作者：Super Z（主监督者）

---

## 〇、资产总账（任何灾难后从此恢复）

| 资产 | 位置（HF 仓 / 远程路径） | 说明 |
|------|------|------|
| HF_TOKEN | 运行时注入（whoami=tchbcb；同私仓 scripts/s8_m13_deploy.py 内嵌值，监督者每次点火时经信封传入） | 双仓读写 |
| 公仓 | `tchbcb/samai-8b-M8` | 权重/GGUF/报告全量 |
| 公开弹药库 | `tchbcb/samai-9b`（公开，README 留空） | merged_m13_r8_hf(18.8G fp16)/m13_r8 LoRA/m13_r8_q4_k_m.gguf/mmproj/llama_cpp_cuda_t4_v2.tar.gz(140M 现场编译完整版)/zagent 包/train.md — T4 拉取即跑 |
| 私仓 | `tchbcb/samai-8b`（LFS 满仓，只下不上大文件） | 脚本/轨迹/样本备份 |
| base 模型 | HF `Qwen/Qwen3.5-9B` → 远程 /tmp/k27/Qwen3.5-9B（19G，xet ~240MB/s） | 训练/合并必需 |
| serving GGUF | 公仓 `m13_r8_mixbit_4x8.gguf`（6.9G，**R10 冠军档**：Q4_K_M 主体+attn/embed/out Q8_0）；另有 m13_r8_q4_k_m.gguf(5.63G 术后版)/m13_r5_q4_fixed.gguf 存档 | 当前 serving 血统 |
| mmproj | 公仓 `mmproj_m11.gguf`（922M）→ /tmp/k8b/ | 视觉塔（冻结不变） |
| 旧版 GGUF | 公仓 `m11_q4_k_m_v2.gguf`、`samai8b_m10_q4_k_m_v2.gguf` 等 | 存档 |
| adapters | 公仓 `m11_final/`、`m11_epoch2/3`、`m12_r1_adapter/`、`m13_r5_adapter/`、`m13_r6/`、`m13_r7/`、`m13_r8/`、`m13_r9/`、**`m13_r10/`（现役，268 窗）**（232-242M 各） | R13 续训种子=m13_r10 |
| CUDA llama-server | 公仓 `lc_build/lc_cuda3.tar.gz`(50.7M, **唯一可用**) → /tmp/lcfin；`artifacts/llama_cpp_cuda_t4.tar.gz`(22M) 缺 libllama-server-impl.so **勿再用(#34)** | 展平 .so + 剥捆绑 libcuda/libnvidia(#33) |
| 93窗语料 | 私仓 `reports/m14/samples_r6.jsonl`（=samples_replay.jsonl, 536KB） | R7 训练底料 |
| 全部轨迹 | 私仓 `reports/m13/traces/*.json` + `reports/m14/traces/*.json` | 建样/复盘 |
| OSWorld 题库 | 私仓 `reports/m14/osworld_tasks.json` + `osw_tasks/osw_a02..a12.task` | computer use 专项 |
| GAIA 题库 | HF `gaia-benchmark/GAIA` 2023-validation → 远程 /tmp/k8b/gaia2/2023/validation/（metadata.parquet + 附件） | L1×53/L2×86/L3×26 |
| zagent_fixed | 远程 /tmp/k12/zagent_fixed（源码 github.com/samaidev/zagent，**PR#188/#189 已合并官方仓=修复点清零**，仅需 ghp token 拉私模块） | Go 1.27 编译；R12 框架补丁二进制 57.3MB 在库 |
| 信封通道 | 旧：env_send.py/env_recv.py + 隧道 URL；**新：aitun.cc 信封 v=1 协议（§四，GVMHKJCU 现役）** | 每次换隧道改 URL |
| 题目工作区 | lproj: s8_m13_seed.py 重种 / lproj3: s8_m14_seed_l3.py 重种 / m12_work: 考题内联 | 种子幂等(random.seed) |

**四源题库速览**：lproj L1/L2（pytest 9用例判分）、lproj L3（unittest 60用例+AUDIT_REPORT）、GAIA（Final answer 列真值判分）、SWE-bench Lite（git diff vs 官方 gold patch）、OSWorld 改编×12（确定性断言）。

---

## 一、一键引导（新 GPU 容器冷启动，完整脚本）

> 适用场景：Kaggle 超时/重启后 /tmp 全空。前置要求：**会话必须挂 GPU**（2×T4 或 P100，无 GPU 时本手册全部训练/推理不可执行）。整段推到远程后台跑，~10 分钟完成。

```bash
#!/bin/bash
# ====== r_boot_m15.sh —— M15 一键引导（粘贴到远程 bash 执行） ======
set -x
export HF_TOKEN=${HF_TOKEN:?"监督者点火时经信封注入 HF_TOKEN 环境变量"}
mkdir -p /tmp/k8b /tmp/k12 /tmp/k27 /tmp/k8b/traces /tmp/k8b/m12_samples /tmp/lcbin
cd /tmp/k8b

# 1) pip 环境（~3min）
pip install -q transformers==5.17.0 2>&1 | tail -1
pip uninstall -y torchao 2>&1 | tail -1          # peft dispatch 不兼容, 必卸
python3 -c "import torch,transformers;print('torch',torch.__version__,torch.cuda.is_available(),'tf',transformers.__version__)"

# 2) CUDA llama-server（~2min）—— v4: 大包直取; 小包缺 libllama-server-impl.so 已废弃(坑#34)
mkdir -p /tmp/lcbin3 /tmp/lcfin
python3 -c "
from huggingface_hub import hf_hub_download
p=hf_hub_download('tchbcb/samai-8b-M8','lc_build/lc_cuda3.tar.gz',local_dir='/tmp/lcbin3')
print(p)"
tar xzf /tmp/lcbin3/lc_build/lc_cuda3.tar.gz -C /tmp/lcbin3 || tar xzf /tmp/lcbin3/lc_cuda3.tar.gz -C /tmp/lcbin3   # local_dir 保留仓库子路径, 双路径回退(坑#35)
LS=$(find /tmp/lcbin3 -name llama-server -type f | head -1)
cp -f "$LS" /tmp/lcfin/llama-server && LBD=$(dirname "$LS")
cp -f "$LBD"/*.so* /tmp/lcfin/ 2>/dev/null
find /tmp/lcbin3 -name '*.so*' -type f -exec cp -f {} /tmp/lcfin/ \; 2>/dev/null   # .so 展平到与二进制同目录
cd /tmp/lcfin && for f in libcuda.so* libnvidia-*; do [ -e "$f" ] && rm -f "$f"; done   # 剥捆绑旧驱动库(坑#33), 强制走宿主 /usr/local/nvidia/lib64
# 验收前置: --version 通过才算阶段完成; 每阶段"验收 && touch FLAG"必须原子(坑#37)
LD_LIBRARY_PATH=/tmp/lcfin:/usr/local/nvidia/lib64:/usr/local/cuda/lib64 /tmp/lcfin/llama-server --version \
  && touch BOOT2_DONE || { echo "FAIL@2 llama-server" >> BOOT_FAIL; exit 1; }

# 3) base + GGUF + mmproj（~2min @240MB/s）
python3 - <<'EOF'
from huggingface_hub import snapshot_download, hf_hub_download
snapshot_download('Qwen/Qwen3.5-9B', local_dir='/tmp/k27/Qwen3.5-9B',
                  allow_patterns=['*.json','*.safetensors','*.txt'], max_workers=8)
print('BASE DONE')
hf_hub_download('tchbcb/samai-8b-M8','m13_r5_q4_fixed.gguf',local_dir='/tmp/k8b')
hf_hub_download('tchbcb/samai-8b-M8','mmproj_m11.gguf',local_dir='/tmp/k8b')
print('GGUF DONE')
EOF

# 4) GAIA 题库（~2min）
python3 - <<'EOF'
from huggingface_hub import snapshot_download
snapshot_download('gaia-benchmark/GAIA', repo_type='dataset',
                  local_dir='/tmp/k8b/gaia2', allow_patterns=['2023/validation/*'])
print('GAIA DONE')
EOF

# 5) 93窗语料 + 轨迹恢复（R7 续训底料）
python3 - <<'EOF'
from huggingface_hub import hf_hub_download
import shutil, os
os.makedirs('/tmp/k8b/m12_samples', exist_ok=True)
p=hf_hub_download('tchbcb/samai-8b','reports/m14/samples_r6.jsonl',repo_type='model')
shutil.copy(p,'/tmp/k8b/m12_samples/samples_replay.jsonl')
for f in ['reports/m14/traces/m14_l3all_conv.json','reports/m13/traces/lp_r2_1_conv.json',
          'reports/m13/traces/lp_r2_2_conv.json','reports/m13/traces/swe_1_conv.json',
          'reports/m13/traces/gaia_1_conv.json']:
    p=hf_hub_download('tchbcb/samai-8b',f,repo_type='model')
    shutil.copy(p,'/tmp/k8b/traces/'+os.path.basename(f))
print('CORPUS DONE')
EOF

# 6) adapter 续训种子（R7 init=m13_r6）
python3 - <<'EOF'
from huggingface_hub import snapshot_download
snapshot_download('tchbcb/samai-8b-M8','m13_r6',repo_type='model',local_dir='/tmp/k8b/m12_adapters/m13_r6')
print('ADAPTER DONE')
EOF

# 7) zagent 源码重建（需要 ghp token，向监督者索取）
# git clone https://<GHP_TOKEN>@github.com/samaidev/zagent /tmp/k12/src && cd /tmp/k12/src
# （Go 1.26: apt install golang 或 snap; go build -o /tmp/k12/zagent_fixed ./cmd/zagent）
# 详细修复点见 train.md §四.zagent

echo "BOOT_ALL_DONE"
```

## 二、serving 启动（131K 长程上下文版，完整命令）

```bash
# 前置: pkill -f llama-server; 确认 GPU 空闲 <500MB
export LD_LIBRARY_PATH=/tmp/lcfin:/usr/local/nvidia/lib64:/usr/local/cuda/lib64
#   ⚠️ 三段全列=安全写法(坑#33): 只写 /tmp/lcfin 会挤掉宿主 nvidia 库 → 旧 compat libcuda →
#   "driver insufficient" → llama-server 静默 CPU 模式(health 仍 ok!) —— GPU 没起来也查不出错
/tmp/lcfin/llama-server \
  -m /tmp/k8b/m13_r5_q4_fixed.gguf --mmproj /tmp/k8b/mmproj_m11.gguf \
  --port 8101 --host 127.0.0.1 -ngl 999 \
  -c 262144 -fa on -ctk q8_0 -ctv q8_0 -sm layer \
  -t 8 --parallel 2 --reasoning-format none --image-min-tokens 1024 \
  > /tmp/k8b/serving.log 2>&1 &
# ⚠️ 坑#41: -c 是总池而非每槽! --parallel 2 会平分 → 131072/2=65536/槽 → 66K 请求 HTTP 400
#   "exceeds available context"。长程题每槽需 ≥120K → 必须 -c 262144 --parallel 2 (KV q8_0 下双卡 ~14G 安全)
# 验收(三条缺一不可): ①curl -s http://127.0.0.1:8101/health → {"status":"ok"}
#   ②nvidia-smi 双卡各 >4G —— 唯一真判据(CPU 模式 health 同样 ok, 坑#33)
#   ③serving.log 出现 CUDA0/CUDA1 层分割加载行
# 冒烟: python3 -c "from PIL import Image; Image.new('RGB',(200,100),(200,30,30)).save('/tmp/t.png')"
#   再 POST /v1/chat/completions 带图, 期望回答含 red circle（视觉通路 OK）
# 注意: -c 必须 ≥25K（zagent 系统提示+工具≈24K）; 长程题用 131072; KV q8_0 省一半显存
```

## 三、zagent 启动 + 两个必配文件（完整内容）

```bash
cd /tmp/k12 && nohup ./zagent_fixed -port 8384 \
  -llm-url http://127.0.0.1:8101/v1 -llm-key sk-local -llm-model samai-8b \
  > /tmp/k12/zfix.log 2>&1 &
# 验收: curl -s http://127.0.0.1:8384/api/agent/status
#   → {"account_id":"...","llm_base":"http://127.0.0.1:8101/v1","online":true,...}
```

`/root/.zagent/llm_config.json`（schema 错 → panic / No LLM model configured；长程版 max_context=120000 必须 < server 131072）：

```json
{"models":[{"name":"samai-m15-9b","provider":"local","api_type":"openai",
  "api_key":"sk-local","api_base":"http://127.0.0.1:8101/v1","model":"samai-8b",
  "enabled":true,"temperature":0.3,"max_tokens":50000,"max_context":120000,
  "reasoning":true,"modalities":["text","image"]}],
 "active_model":0,"subagent_model":0}
```

`/root/.zagent/system_prompt.txt`（zagent 追加为 ADDITIONAL INSTRUCTIONS, agent.go:1256——**计划JSON卡死的根治手段**）：

```text
[执行纪律 - 最高优先级]
1. 收到任务后禁止输出 workflow 或计划 JSON（不要调用 manage_workflow，不要输出 {"action": ...}），必须直接逐步调用工具执行。
2. 每个回复要么是工具调用，要么是最终结论；禁止只输出计划并等待确认。
3. 遇到错误必须分析输出并换方法重试，直到完成或确认不可行。
4. 浏览器自动化优先用 python3+playwright（chromium 已装；root 用户需 headless=True 与 args=['--no-sandbox']）。
5. 长程任务: 先写 PROGRESS.md 记录已完成项与下一步; 每完成一个子项就追加一行, 上下文被压缩后靠它续作。
6. 修复代码时只改函数体, 绝不删除/改名函数与 import; 改完立即重跑测试验证。
7. 完成后给出最终回答：结果摘要 + 产出文件路径清单。
```

**zagent 源码重建修复点**（github.com/samaidev/zagent，Go 1.27；2026-09-23 复核：**PR#188/#189 已合并官方仓，全部补丁上游化，本地修复点清零**）：
- 上游已含：反环硬闸（同 sig 2 过 3 拦+HARD SYSTEM BLOCK，全库 4 处执行站点全覆盖：agent.go×2 + web_stream.go×2）/ SyncLLMFromConfig nil-guard / [Main]PANIC debug.Stack / analyze_video 本地帧提取 / antiLoopSig 空白归一化（防微变参数绕闸）
- 已知上游预存坏测试：compact_test.go 引用从未存在的 searchSession（f126f65 起）——跳过勿修
- 私源依赖拉取：`git config --global url."https://<GHP_TOKEN>@github.com/".insteadOf "https://github.com/"` + `export GOPRIVATE=github.com/samaidev/*`（坑#55，两者缺一不可）
- 编译：`go build -o /tmp/k12/zagent_fixed .`（**main 包在仓库根**，无 cmd/zagent 子目录; 坑#40）；R12 产物二进制 57.3MB（单测 4 项过）在 HF zagent 包

## 四、信封通道（监督者的手）

本地两个文件（私仓 scripts/ 有备份）：`env_send.py`（发）、`env_recv.py`（收）。用法：

```bash
python3 env_send.py https://aitun.cc/<TUNNEL> <script.py> [timeout秒]
python3 env_send.py https://aitun.cc/<TUNNEL> -c 'print(40+2)' 30   # 期望 42
```

铁律：
- **body ≤4KB**：大脚本用 gen_push.py 分段推送（本地生成 wrapper 序列→逐个 env_send→远程拼装→MD5 校验）
- **~180s 网关超时**：长任务一律 Popen `start_new_session=True` 分离点火，轮询 flag 文件
- **exec 槽三坑**：函数体看不见顶层 import（import 写进函数体内）/推导式翻车/嵌套函数不可见
- 超时的信封可能仍在远程执行 → 连发前先小探针确认执行槽空闲

**信封 v=1 协议（aitun.cc，2026-09-23 起 GVMHKJCU 现役）**——body 纯 text/plain 五段式：

```text
samaicmdbegin
v=1
enc=b64url
crc=<zlib.crc32(payload) 8位小写hex>
<b64url payload，76 字符换行>
samaicmdend
```

发射：`curl -s --data-binary @- 'https://aitun.cc/<TUNNEL>/execute?respenc=b64url&timeout=N'`（timeout 默认 600，上限 1800；响应字段均 base64url，解码后补 `===` 再读）。本地造信封两行：`zlib.crc32(payload).to_bytes(4,'big').hex()` + `urlsafe_b64encode(payload)`。连通性验收：payload=`print(40+2)` 回显 42 即全通。旧 env_send.py 对旧网关仍有效。

## 五、发题（完整脚本 s8_m15_gaia_fire.py，GAIA L3 例）

**姿势铁律**：`mode=single` + 显式 `conv_id` + `curl --max-time 8` + Popen 分离。禁止 urllib 长阻塞读 SSE（执行槽死锁）。

```python
# /tmp/k8b/s8_m15_gaia_fire.py — 用法: python3 s8_m15_gaia_fire.py <题idx> <conv_id>
import json, os, sys, time, subprocess
K8B="/tmp/k8b"; GA=K8B+"/gaia2/2023/validation"; OUT=K8B+"/traces"
os.makedirs(OUT, exist_ok=True)
idx=int(sys.argv[1]); conv=sys.argv[2]
import pandas as pd
df=pd.read_parquet(GA+"/metadata.parquet")
l3=df[df["Level"].astype(int)==3].reset_index(drop=True)
r=l3.iloc[idx]
fn=r.get("file_name"); att=""
if isinstance(fn,str) and fn:
    ap=os.path.join(GA,fn)
    if os.path.exists(ap):
        att="\n\nAn attachment for this task is saved locally at: %s (use your tools to read/analyze it with python/code execution)."%ap
msg="""You are solving a task from the GAIA benchmark (Level 3), a real-world assistant evaluation. Work through it step by step with your tools.

Task:
%s
%s

Execution discipline:
- Reason and act with tools directly (command execution, file reading, code execution, web fetch/search). Never output a plan/workflow JSON and stop.
- Break the problem into verifiable sub-steps; cross-check every fact with at least one authoritative source before concluding.
- If an intermediate result depends on a file, inspect the file first (columns, units, formats) before computing.
- Keep notes of intermediate findings in your working notes file so you can recover after any context compression.
- The final answer must be concise exactly as the task requests.

When finished, output the final answer on its own last line in the exact format: FINAL ANSWER: <answer>"""%(str(r["Question"]),att)
body=json.dumps({"message":msg,"conv_id":conv,"model_index":0,"mode":"single"})
open(OUT+"/%s_msg.json"%conv,"w").write(body)
open(OUT+"/%s_state.txt"%conv,"w").write("FIRED %s tid=%s ans=%s\n"%(time.strftime("%H:%M:%S"),str(r["task_id"])[:8],str(r["Final answer"])[:80]))
cmd=("curl -s --max-time 8 -X POST http://127.0.0.1:8384/api/chat/send/stream "
     "-H 'Content-Type: application/json' --data-binary @%s/%s_msg.json > %s/%s_fire.log 2>&1"%(OUT,conv,OUT,conv))
subprocess.Popen(['bash','-c',cmd],start_new_session=True,
                 stdout=subprocess.DEVNULL,stderr=subprocess.STDOUT,stdin=subprocess.DEVNULL)
print("FIRED",conv,"tid",str(r["task_id"])[:8])
```

**判分**（s8_m15_gaia_judge.py）：从 `<conv>_state.txt` 取 ans= 真值，与轨迹末条 assistant 的 `FINAL ANSWER:` 行规范化比对（小写/去冠词/数字容差），结果追加 `traces/judge_m15.jsonl`。用法：`python3 s8_m15_gaia_judge.py [conv_id ...]`（缺省判全部 m15_g3*）。完整源码私仓 scripts/。

**发题模板环境注记**：容器工具故障（web_search 404 / stealth_browser 崩）时，在 Execution discipline 块内加一行：`- ENVIRONMENT: the web_search tool is broken here (always 404). Do NOT call web_search or stealth_browser. For web access use web_reader on direct URLs or execute_code (python requests / Wikipedia REST API).` —— 实测生效（新卷 web_search 调用 0 次, 直奔 execute_code）；对已 running 的狂暴环发 hint 无效(坑#42)。

**其它题源发题器**：lproj 用 s8_m13_lproj_run.py / lproj3 用 s8_m14_seed_l3.py 种好后按 m14_l3a..f 姿势直发；SWE 用 s8_m13_swe_run.py（parquet 列名 problem_statement）；OSWorld 用 /tmp/lproj_osw/*.task 逐题直发。

## 六、监督轮询（完整脚本 r_m15_watch.py）

```python
# /tmp/k8b/r_m15_watch.py — 用法: python3 r_m15_watch.py [conv_id]  （经信封调用）
import subprocess, sys
CONV = sys.argv[1] if len(sys.argv) > 1 else "m15_g3a"
def sh(c, t=25):
    p = subprocess.run(c, shell=True, capture_output=True, text=True, timeout=t)
    return (p.stdout + p.stderr).strip()
print("== STATUS =="); print(sh('curl -s -m 6 "http://127.0.0.1:8384/api/chat/task/status?conv_id=%s"'%CONV))
print("== PROGRESS ==")
print(sh("""python3 -c "
import json
d = json.load(open('/root/.zagent/web_conversations/%s.json'))
ms = d.get('messages', [])
from collections import Counter
tools = Counter(m.get('tool_name') for m in ms if isinstance(m,dict) and m.get('tool_name'))
print('msgs',len(ms),'tools',dict(tools))
for m in reversed(ms):
    if isinstance(m,dict) and m.get('role')=='assistant':
        print('LAST:', str(m.get('content'))[:300].replace(chr(10),' | ')); break
" 2>&1 | head -6"""%CONV, 20))
print("== GPU =="); print(sh("nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv,noheader"))
print("== STOP RULES ==")
print("running:true 但 11min 无新消息/无 LLM 调用 = 假死 → 截停: curl -s -X POST http://127.0.0.1:8384/api/chat/task/stop -H 'Content-Type: application/json' -d '{\"conv_id\":\"%s\"}'"%CONV)
print("截停后立即备份: cp /root/.zagent/web_conversations/%s.json /tmp/k8b/traces/%s_conv.json"%(CONV,CONV))
```

监督节奏：每 3-5min 一次信封轮询；修复数收益递减（修7→2→0→0）即收官截停；**每段停机立即备份轨迹**（丢 15 步的血泪教训）。

## 七、建样 → 爆发训练（完整脚本 r_burst_r7.py）

```python
# 1) 建样（窗口回放防遗忘—— samples 第 i>0 窗 user = 任务节选+前窗进度回顾+上一窗末尾2块动作回放+续作指令）
#    python3 /tmp/k8b/s8_m14_build_replay.py m15_g3a m15_g3b ...   # 追加到 samples_replay.jsonl
#    然后: tail -n <新增行数> samples_replay.jsonl > samples_r7.jsonl
#    cat /tmp/k8b/m12_samples/samples_replay.jsonl >> ... 也可全量(93窗+新窗)重训
# 2) 爆发:
import subprocess, os, time
K8B="/tmp/k8b"; log=open(K8B+"/burst_r7.log","w",buffering=1)
def L(m): log.write("[%s] %s\n"%(time.strftime("%H:%M:%S"),m))
def sh(c,t=300): return subprocess.run(c,shell=True,capture_output=True,text=True,timeout=t)
CK=K8B+"/ckpt/sft_8b_m13"
for f in ["TRAIN_FAIL","TRAIN_DONE","TRAIN_NAN","TRAIN_RUNNING"]:   # burst 假阴性预防: 必清陈旧旗标
    try: os.remove(CK+"/"+f)
    except OSError: pass
sh("pkill -f llama-server"); time.sleep(3)                          # 停 serving
sh("kill -9 $(nvidia-smi --query-compute-apps=pid --format=csv,noheader) 2>/dev/null")
for i in range(24):                                                  # 排干 GPU <500MB
    time.sleep(5)
    r=sh("nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits")
    if sum(int(x) for x in r.stdout.split() if x.strip().isdigit())<500: break
env=dict(os.environ)
env.update({"M12_ADAPTER_INIT":"/tmp/k8b/m12_adapters/m13_r6",      # 续 m13_r6 血统
            "M12_DATA":"/tmp/k8b/m12_samples/samples_r7.jsonl",
            "M12_OUT":"/tmp/k8b/ckpt/sft_8b_m13","M12_ROUND":"r7",
            "M12_EPOCHS":"1","M12_ACC":"3","M12_LR":"1e-4","M12_MAXLEN":"2048"})
tr=subprocess.Popen(["python3",K8B+"/s8_m13_train_v8.py"],stdout=open(K8B+"/train_r7.log","w"),
                    stderr=subprocess.STDOUT,start_new_session=True,env=env,cwd=K8B)
ok=False
for i in range(100):
    time.sleep(30)
    if os.path.exists(CK+"/TRAIN_DONE"): ok=True; L("TRAIN_DONE"); break
    if os.path.exists(CK+"/TRAIN_FAIL"): L("FAIL: "+open(CK+"/TRAIN_FAIL").read()[:300]); break
    if os.path.exists(CK+"/TRAIN_NAN"): L("NAN"); break
    if tr.poll() is not None: L("exit rc=%s"%tr.returncode); break
if ok:
    sh("cp -r %s/final %s/m12_adapters/m13_r7"%(CK,K8B))            # 快照
    sh("rm -f %s/m12_adapters/m13_r7/TRAIN_DONE"%K8B)
env2=dict(os.environ); env2["LD_LIBRARY_PATH"]="/tmp/lcfin:/usr/local/nvidia/lib64:/usr/local/cuda/lib64"  # 追加式三段(坑#33)
srv=["/tmp/lcfin/llama-server","-m",K8B+"/m13_r5_q4_fixed.gguf","--mmproj",K8B+"/mmproj_m11.gguf",
     "--port","8101","--host","127.0.0.1","-ngl","999","-c","262144","-fa","on",   # 总池=2×每槽(坑#41)
     "-ctk","q8_0","-ctv","q8_0","-sm","layer","--image-min-tokens","1024","-t","8",
     "--parallel","2","--reasoning-format","none"]
subprocess.Popen(srv,stdout=open(K8B+"/serving_r7restore.log","w"),stderr=subprocess.STDOUT,
                 stdin=subprocess.DEVNULL,start_new_session=True,env=env2)
open(K8B+("/BURST_R7_DONE" if ok else "/BURST_R7_FAIL"),"w").write("r7")
# 训练器 s8_m13_train_v8.py: 私仓 scripts/, 环境变量驱动, MTrainer 分块fp32 CE(CH=256), W_TOK=1800 MAXLEN=2048
# 健康判据: loss 下降 + grad_norm 0.5~3 无 nan; ~10s/步(文本窗) ~80s/步(含图) — R7 实测 ~30s/步(105窗)
```

### §七甲·反死环训练窗（M15 死环根治专用, antiloop_build.py 私仓 scripts/）

**病理**：Qwen 长程任务中确定性死环两种形态——周期-1（同一调用逐字节重复, 实测最多 107 连）与周期-2（两个等价变体交替, 实测 49 轮）；特征=同一 md5(tool_args) 反复出现且观察无变化。

**三窗型**（数据全部来自真实死环轨迹, 不编造观察）：
- A 止损决策窗：全环证据回放 + 执行监测警报(⚠️检测到确定性死循环) → target=[思考]环识别+根因+终止决策 → [最终回答]收束
- B 早断换路窗：仅 2 次重复回放+无警报 → target=自发识别(第二次逐字节重复即应视为路径存疑) → [行动]换真实替代调用(轨迹中 sig 不同的成功调用)或收束
- C 配额收束窗：真实一次配额轨迹(收官卷 g3a2/g3b3) → target=配额服从(一次调用→观察→立即收束, 绝不重试)

**建样器 M15 修正**（build_replay）：task 取首条 user(非末条——stop 后收官消息留空尾会致 blocks 全空 SKIP)；工具链取全卷(长卷含多轮 user 干预)；thinking 错位砍除(坑#45)。

**M15 实测**：6 环全捕获(g3a 76 连 / g3b 43+107 连 / g3b2 周期-2 49 轮 / g3c 46+60 连) → 13 反死环窗 + 41 回放窗 + 93 旧窗 = 147 → R7 爆发 35 步 loss 0.5166 (m13_r6→m13_r7)。

**框架级硬约束（根治的第二条腿，R7 上线后实测）**：R7 微调后死环仍复发（g3c2 复合周期-2 环）——微调是概率压制不能根除。已给 zagent 打代码级反环补丁：
- 位置：web_stream.go 两处 Execute（streaming+fallback）+ agent.go 两处（坑#47）；sig=parse 后 args 的 json.Marshal（坑#48）；key=sourceLabel（=conv 稳定标识）
- 语义：同 sig 连续 3 次起硬拦截（不执行，向 LLM 回喂 HARD SYSTEM BLOCK 伪造 tool result），周期-1/周期-2 均覆盖（最近两 sig 各自计数）
- 实战：g3c3 死环 6 连拦（blocked #3-#6），模型被拦后尝试换路（curl 下载→换查询源），行为闭环完成；数据经短上下文新卷收官收割
- 结论：**微调塑形 + 框架硬约束 = 双保险**；框架层是任何模型都生效的根治手段。

**R10-R12 长窗纪律轮增补（2026-09-23/24，v4.5）**：
- **R10 终审（量化无罪）**：serving 级长短双维探针（s8_sprobe_r10.py 短 A/B/C + s8_sprobe_long.py 500 步填充≈25K token+末尾两振回放）——Q4 短全 PASS/长 WEAK；f16 对照长同 WEAK（think 认知在线、行为跟填充走=**think-行为解离**）；Q6_K 主体档反而 A=FAIL（反单调铁证）。结论：纪律失效=**长上下文泛化缺失**（R8 窗全 ~1800 token 短回放），与量化档位无关。冠军档=mixbit_4x8（6.9G）
- **R11 长窗课程**（r11_curriculum.py）：K（重复/拦截次数）×填充长度（2K/8K/20K/40K）×任务域网格化；W1 拦截后换路/W2 拦截后收束 FINAL/W3 双振换路三窗型 + 视频窗三型；W_TOK 上限放开（1800→真长窗）；训练 OOM 梯子 6144→3400（坑#66）
- **R12 五靶点**：T1 行为判据 / T2 诚实窗 / T3 纯文本收束 / T4 录屏 recipe（Xvfb+x11grab）/ T5 框架补丁（Go 二进制 57.3MB，单测 4 项过）；R11+R12 合计 **268 窗**（210+58）→ **m13_r10 已推 HF**
- **坑#44 终极再证**：testB2 模型无视 77 连 HARD BLOCK 继续原样重发 execute_code；复检中 analyze_video 成功后对 call_llm 原样重发 16 次——框架正确/模型惯性无视拦截的活体铁证，双保险缺一不可

## 八、部署链（merge→convert→Q4→手术→推仓，完整要点）

```python
# s8_m15_deploy_r6.py 模式（完整源码私仓 scripts/; 后台分离点火, 各阶段写 flag 可重入）
# 1) merge: AutoModelForImageTextToText.from_pretrained(BASE, fp16, device_map='cpu') + PeftModel(ADP) + merge_and_unload + save
#    ADP=/tmp/k8b/m12_adapters/m13_r6 (232MB, adapter续训含全部血统)
# 2) convert: cd /tmp/k27/llama.cpp && NO_LOCAL_GGUF=1 PYTHONPATH=$LC/gguf-py python3 convert_hf_to_gguf.py MERGED --outfile F16 --outtype f16
#    ⚠️ 抢救包里 convert_hf_to_gguf.py 可能是 13KB stub → 需上游 llama.cpp 的 conversion/ + gguf-py/ 三件套
# 3) quantize: $LC/build/bin/llama-quantize F16 Q4 Q4_K_M
# 4) 手术(每次必做): python3 /tmp/k8b/surgery_gguf.py Q4_raw Q4_fixed   # blk.32/MTP 缺陷修复
# 5) push: HfApi().upload_file → m13_rN_q4_k_m.gguf + sha256 文件 + 远端 hf_hub_download 校验
# 6) 磁盘守卫: 删 MERGED(19G)+F16(19G)+Q4raw(5.6G), 留 Q4_fixed
# 7) 换装: pkill llama-server → §二命令改 -m Q4_fixed → health → 同题实测对比基线
# 磁盘预算: base19G+merged19G+f16_19G+q4_5.6G ≈ 63G < 1T 安全
```

---

### §八甲·GGUF 手术借壳战术（v4.4 实战新增: surgery_gguf.py 全量重写 OOM 的解法）
- 适用: 手术时 RAM 不足以让 gguf-py Writer 全量攒 5.6G 张量数据(RAM 31G 可用 19G 亦炸)
- 原理: 同 base 同 LoRA rank 的相邻两代(r5/r7/r8)合并+量化后 **427 张量布局全等**(名字/顺序/形状/dtype 一致, data_offset=10967488 相同, 文件总大小相等) → 前代术后 gguf 当"壳"(metadata 正确含 block_count=32 补回), 本代 quantize 产物当"瓤"(张量数据区), 字节级拼接
- 前置校验(GGUFReader): data_offset 相等 + 张量名序列全等 + 文件总大小相等, 三者任一不等 → 回退 surgery_gguf.py
- 拼接: 头部=壳[:data_offset](replace Merged_R7_Hf→Merged_R8_Hf) + 瓤[data_offset:]流式 64MB 分块拷贝; 校验=首/中/尾各 1MB 与瓤逐字节相等
- 落地: s8_m15_deploy_r8.py stage5 已内置(SPLICE 优先, 自动回退 surgery_gguf.py); 手工版 splice_r8b.py
- 实测: R8 借壳拼接 DEPLOY 全链通过, serving 加载 12s, 探针行为正常

## 九、踩坑速查表（54 条血泪浓缩）

| # | 坑 | 解法 |
|---|----|------|
| 1 | 信封 body>4KB 被截 | gen_push.py 分段+MD5 |
| 2 | ~180s 网关超时 | Popen 分离点火+flag 轮询 |
| 3 | exec 槽函数看不见顶层名 | import/常量全写函数体内 |
| 4 | urllib 读 SSE 死锁执行槽 | curl --max-time 8 + Popen |
| 5 | mode=task+空conv 幽灵任务 | mode=single+显式 conv_id |
| 6 | session-review 600s 复活死任务 | 删会话文件+重启 zagent |
| 7 | 计划 JSON 卡死 | 纪律条款(§三)+题内联双保险 |
| 8 | running:true 假死(11min 无LLM调用) | task/stop 截停+备份轨迹 |
| 9 | tool_args 损坏→"empty command" | agent 自重试(训练素材) |
| 10 | nudge 污染样本锚点 | 锚 users[0]/任务前缀 |
| 11 | 思维链提取 | llm_logs.db 表 llm_call_logs resp_raw [reasoning] 行 |
| 12 | fp16 9B 单卡 OOM | 双卡分摊 device_map=auto |
| 13 | QLoRA 4bit CE fp32 上转 OOM | 放弃 QLoRA, fp16+分块 CE |
| 14 | MAXLEN 640 中文样本全过滤 | MAXLEN≥2048 |
| 15 | lm_head modules_to_save 崩 PEFT | 爆发模式三件套 |
| 16 | 僵尸训练进程占显存 | kill compute-apps+排干<500MB |
| 17 | burst 误判失败 | 点火前清 4 个陈旧旗标 |
| 18 | transformers 5.0.0 不识别 qwen3_5 | 固定 5.17.0 |
| 19 | torchao 0.10 与 peft 冲突 | 必卸 |
| 20 | CUDA_VISIBLE_DEVICES 被 pop | 训练脚本删 pop 行 |
| 21 | convert 产物 blk.32 缺陷 | surgery_gguf.py 每次必跑 |
| 22 | convert stub 13KB 缺 conversion/ | 上游三件套 |
| 23 | llama-server CPU 编译装不上 | /tmp/lcbin/bin CUDA 版 |
| 24 | ctx 8192 报 exceed(系统提示24K) | -c ≥25K, 长程 131072 |
| 25 | max_context 200K > server 131K | zagent 120000 |
| 26 | 修复时删函数致 ImportError | 题面+纪律条款写明"只改函数体" |
| 27 | 续作收益递减不止损 | 修N单调降→收官截停 |
| 28 | 停机不备份丢轨迹 | 每段停机立即 cp traces/ |
| 29 | adapter README 坏(本地路径) | 干净版 base_model: Qwen/Qwen3.5-9B |
| 30 | 推仓未校验 | sha256 远端下载比对 |
| 31 | /tmp 全灭 | 一切推 HF, §〇 资产总账重建 |
| 32 | huggingface_hub 新签名: repo_type 变 keyword-only | 显式 repo_type=; snapshot 失败改 hf_hub_download 逐文件 |
| 33 | LD_LIBRARY_PATH 只写包目录 → 挤掉宿主 nvidia lib64 → 旧 compat libcuda → 静默 CPU(health 仍 ok) | 追加式三段 /tmp/lcfin:/usr/local/nvidia/lib64:/usr/local/cuda/lib64; 包内捆绑 libcuda.so*/libnvidia-* 先剥离; 验收看 nvidia-smi>4G |
| 34 | 小包 llama_cpp_cuda_t4 缺 libllama-server-impl.so | 大包 lc_build/lc_cuda3.tar.gz 直取, 小包废弃勿再试 |
| 35 | hf_hub_download local_dir 保留仓库子路径(如 lc_build/) | tar 双路径回退: 先 子路径/包名 后 包名 |
| 36 | gen_push 收端 zlib.decompress 遇 gzip 包炸 incorrect header | 格式配对: gzip.compress↔gzip.decompress |
| 37 | boot 阶段验收行丢失, 无验收也 touch DONE | "验收命令 && touch FLAG" 原子一行; 复跑先核 flag 与实际进程一致 |
| 38 | GAIA gated repo 401(token 有效仍拒) | 账号在 HF 网页接受数据集协议后 token 才放行 |
| 39 | Write 工具把 \n 转 literal newline 破坏补丁 | 补丁内换行用 chr(92)+"n" 生成 |
| 40 | zagent main 包在仓库根(无 cmd/zagent), Go 1.27 | go build -o ... .(根目录编译) |
| 41 | llama-server -c 是总池非每槽: 131072+parallel2 → 65536/槽 → 66K 请求 HTTP 400 | 长程版 -c 262144 --parallel 2 (每槽131K); 出错特征: "exceeds the available context size (65536)" |
| 42 | 工具狂暴重试环: 坏工具(如 web_search 404)秒回秒试, 5min 刷 58 消息, 中途 hint 无效 | 立即 task/stop + 备份轨迹 + 换新卷重发(任务内嵌"禁用该工具, 改用 X"注记); 干净锚点>污染续命 |
| 43 | 信封载荷 4192B 侥幸过闸(超 3000B 安全线) | 铁律仍 ≤3KB: 超限拆 gen_push, 侥幸过闸≠安全 |
| 44 | 死环中的 Qwen 对一切软指令免疫: HARDWRAP/quota(一次配额)/HARDFIN 三连全被无视, "失败不得重试"照旧重试, 配额被挪去继续惯性调用 | 唯一硬解: task/stop 硬停 + 短上下文新卷收官(已确认事实浓缩进首条消息+禁工具直答); 代码级强制令(逐字喂 pandas 代码)可破惯性; 根治=反死环窗微调(§七甲) |
| 45 | 新版 zagent llm_logs resp_raw 为 <think>原文 非 [reasoning] 前缀行 → 旧提取器 0 命中; 多卷并发下 thinking 与工具调用错位 | 建样宁缺毋滥: 砍 [思考] 映射, 仅保留 [行动]/[观察] 诚实序列; reasons_seq 需双格式兼容 |
| 46 | 新版 transformers AutoProcessor 不再继承 chat_template(tok.ct=True/proc.ct=False) → apply_chat_template 全灭 "no samples encoded" | processor 加载后显式兜底: proc.chat_template = tok.chat_template; 双缺则注入 Qwen im_start/im_end 兜底模板 |
| 47 | web conv 的工具执行在 web_stream.go(双路径 streaming+fallback), agent.go 的 handleToolCalls 补丁不生效 | 补丁前先定位入口: grep -rn 'Web-Tool' 日志源 → 找到真正执行文件; web_stream 两处 Execute 都要拦 |
| 48 | 环检测 sig 用 raw Arguments 会因 JSON 转义漂移(\\n vs \\u)永不命中 | sig 必须用 parse 后 args 的 json.Marshal(键序确定); key 用 sourceLabel(=conv 稳定标识), 勿用 msg.ReplyToID(每条唯一) |
| 49 | 部署链被陈旧 DEPLOY_ALL_DONE 旗标挡住秒退("in 0s") | 重入前必 rm -f /tmp/k8b/DEPLOY_*; 旗标可重入设计只防中断不防换代 |
| 50 | 隧道 agent 僵死: nginx 301 秒回但容器侧全路径超时, 长任务全挂 | 用户从 Kaggle 控制台重启隧道进程; /tmp 资产不损; 挂 50s 自动探针监控 |
| 51 | CMake 报 target CUDA::cuda_driver not found = 容器只有版本号真身 libcuda.so.580.x 无 dev 符号链接 | ln -sf $(ls /usr/local/nvidia/lib64/libcuda.so.* \| head -1) /usr/lib/x86_64-linux-gnu/libcuda.so 后重 cmake |
| 52 | 抢救 tar 包(llama_cpp_cuda_t4.tar.gz)实测只含 ggml 库缺 libllama-server-impl.so 全家(坑#34 结案: 无法靠解包救) | 现场源码编译: git clone llama.cpp && cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=75(T4=sm75 限定加速) -DLLAMA_CURL=OFF && cmake --build build --target llama-server llama-quantize llama-cli -j4; 产物 build/bin/* + build/src/*.so* 全部平铺 /tmp/lcfin(混用旧 ggml 库会版本冲突, 先 rm 旧 .so*) |
| 53 | 容器自带 transformers 5.0.0 不认 qwen3_5(KeyError: 'qwen3_5', AutoConfig 拒载) | pip install -U transformers(5.17.0 实测过); 训练链(peft/processor)兼容性同步验证 |
| 54 | peft 0.19 + torchao 0.10 冲突: PeftModel 注入即 ImportError(torchao >= 0.16 required) | pip uninstall -y torchao + pip install -U peft(0.21.0); torchao 非训练必需, 卸载最干净 |
| 55 | go build 私仓模块 401: 主仓 clone 带 token 不够, go module 下载走裸 https://github.com/ | git config --global url."https://TOKEN@github.com/".insteadOf "https://github.com/" + export GOPRIVATE=github.com/samaidev/*; 两者缺一不可 |
| 56 | 源码多处注入补丁器双坑: ①循环内第二次 find(needle) 仍命中第一处→双块叠装语法错(固定偏移 +800 对 >800B 的注入块同样失效) ②key 拼接表达式漏引号(SYNC\|"+sourceLabel 丢前引号) | ①前进指针: pos=find(needle,prev); 注入后 prev=ls+len(blk)(=新串中 needle 起点) ②key 用完整 Go 表达式字符串('"SYNC|"+sourceLabel'); 每处注入后打印缩进长度验证落点不同(ind 2/4=异站, 5/5+同站=事故) |
| 57 | snapshot_download local_dir 保留仓库子路径 → 双层嵌套（merged_hf/merged_hf/），下游 convert 找 config.json 秒退 | 落地后先 ls 验层级再接链；或改 hf_hub_download 逐文件；convert 前侦察真实路径 |
| 58 | 新 llama.cpp 日志格式无 CUDA0/1 分割行 → 换装脚本 SWAP_FAIL 误报（实际健康） | serving 三判据以 health ok + nvidia-smi >4G 为准；日志行判据随 llama.cpp 版本校准 |
| 59 | hfget 小文件误报 GET_FAIL（>1e6 字节阈值误判），文件实际落地可用 | 以本地落地文件 MD5 vs HF raw 拉取 MD5 对齐为准，勿信单阈值 |
| 60 | llama-quantize 位置参数制: flag 后置被当 nthread 吞; fork 的 ftype 表无 q8_k_m（双写法均拒）; 与 serving 抢卡 CUDA init 崩 | flag 全部前置; 第三档用 q8_0 替代; 量化跑前 CUDA_VISIBLE_DEVICES= 置空 |
| 61 | GGUF 手术类型表三错（INT16/FLOAT32/FLOAT64）是万恶之源; pack_into 落点早 4B 腐化 vtype/etype | 手术前 KV 遍历+hex 字节签名取证; BOOL=1B(et7); 删字节后 padding 吸收位移张量零触碰; 落点按新串起点重算（r11/r12_surgery.py 已固化） |
| 62 | 部署脚本模板占位符顺序: flag 在 binary 前 = shell 当命令 3 连修 | flag/binary 严格按 CLI 语法序拼装; 拼完先 --version 冒烟再入链 |
| 63 | zagent 执行站点全库 4 处 agent.go 仅 2: runWebAgentLoop→loopToolCtx.Execute 路径裸奔（闸 0 命中）; 微变参数绕闸 | 新执行路径必须补闸（web_stream.go×2）; antiLoopSig 空白归一化（PR#189 已上游） |
| 64 | bash 长命令 sleep>~600s 被杀且同调用 heredoc 回滚 | 长操作 nohup 分片 + Write 工具中转落盘, 绝不单条 bash 长阻塞 |
| 65 | 部署脚本旗标双前缀 bug（r12_pipeline.py S3 的 DEPLOY_ 重复）→ 秒退/误判 | 部署只用修正版 r12_deploy_r10.py; 重入前 rm -f /tmp/k8b/DEPLOY_*（#49 复核） |
| 66 | R11 长窗训练 OOM（W_TOK 放开后） | 梯子 6144→3400 降窗口; 长窗按长度分桶/降 batch; OOM 不退课程只降窗口 |
| 67 | aitun 免 token 隧道同机单身份: 第二个客户端实例顶掉第一个（Connection replaced by newer connection of this client） | 真双隧道需 -k 账户 token; 单隧道双功能走 kaggle_server /v1 代理补丁（备选 router_8102.py 独立复用器） |
| 68 | kaggle_server 与 aitun 客户端都有监督环（jupyter kernel 自动重生）→ 抢端口/改 -p 必被弹回 | 补丁本体文件 + kill 让监督环带补丁重生; 兜底自检自启（oneclick restart_ksguarded） |
| 69 | 信封内无界 grep/find 扫 /tmp（40G 模型盘）→ 30s 超时误判 | 远端搜索必须 maxdepth + -size -2M + 排除模型目录 |
| 70 | 双 /health 同名: kaggle_server /health（富信息）vs llama /health（{"status":"ok"}） | 经代理后验 llama 存活用 /v1/models; /health 富信息=执行桥活的标志 |

## 十、历轮战绩

| 轮 | 题源 | 结果 | 训练 |
|----|------|------|------|
| M12 R1 | 综合 T1-T6B | 4.5/6; 计划JSON失败→纪律条款根治 | R1: 5步 1.246→0.672 |
| M13 R2/R3 | lproj L1/L2 | 9/9 PASS; 二轮提速 5 倍 | R2 5步→0.575; R3 6步→0.62 |
| M13 R4 | SWE astropy-12907 | diff 与 gold patch 逐字一致 | R4 10步→0.53 |
| M13 R5 | GAIA L2 带图 | ◐ 程序化图像分析 | R5 6步→1.01 |
| M13 部署 | m13_r5 换装 | 同题提速 **6.5 倍** (65min→<10min) | — |
| M14 ① | lproj L3 超长程 | 6段183步/168工具步, 31 修复; 峰值 66.6K→压缩回落→续涨 | — |
| M14 ③ | 93 窗回放 | 四源+lproj3 全量回放建样 | **R6 30步 1.035→0.4096 历轮最低** |
| M15 | GAIA L3 | 判分 0/2(#19/#14)但收官链路+死环病理全采集; 6 环→13 反死环窗 | R7 35步 0.5166 (m13_r6→r7) |
| R8 | GAIA #13 终审 | 死环复发实锤（3min 周期-1 ×99 连, 框架 100+ 连拦零失控）; "纪律死于 Q4"假说提出（后被 R10 推翻） | R8: 65步 0.3648 (m13_r7→r8, 235 窗) |
| R9 | 新容器+部署链全通 | KV 原地手术两役（recurrent_layers/nextn）; 强制收官卷 FAIL 如实记录 | — |
| R10 | 混合精度梯子 | **量化无罪终审**（Q4/f16 双对照+长短双维探针）; 4x8 冠军档上线; think-行为解离实锤 | — |
| R11 | zagent PR×2+视频工具 | PR#188/#189 合并; 视频工具✅逐字读帧; computer-use❌拦截免疫→转训练靶 | R11: 210 长窗 (m13_r8→r9) |
| R12 | 五靶点 T1-T5 | 行为判据/诚实窗/纯文本收束/录屏 recipe/框架补丁（Go 57.3MB 单测 4 项过）全落地 | R12: 58 窗, **总计 268 窗 (m13_r9→r10)** |
| R13 | GSQ-RCO-lite 四段链（链重建→imatrix→DP 背包逐张量→容器量化; 参 GSQ 2604.18556 + RCO 2605.00649） | mixbit 8.11 → **gsqrco_v1 7.99 ppl**; container_q40 7.84; imatrix q8 参考 5.07; serving 35.9 tok/s | — |
| R14 | 代码仓同步 + 隧道六死 + 单隧道复用 | FNH0ITO4 判死（坑#50 六现）; 8RF5ST7K 公网 /v1 全绿（models/chat/SSE 流式, key=1234）; lora 按 git 史新者为准覆盖 | — |

## 十一、R12 收官状态存档（2026-09-24 · Colab T4 部署轮）

R11/R12 长窗纪律轮已收官，m13_r10 落地：
- **R11 训练**：210 长窗（r11_curriculum 课程：W1 拦截后换路/W2 拦截后收束/W3 双振换路 三窗型 × 2K-40K 深度 + 视频窗），W_TOK 放开，OOM 梯子 6144→3400（坑#66）；血统 m13_r8→m13_r9
- **R12 训练**：58 窗五靶点（T1 行为判据/T2 诚实窗/T3 纯文本收束/T4 录屏 recipe/T5 框架补丁）→ 合计 **268 窗**；血统 m13_r9→**m13_r10 已推 HF**
- **R12 框架补丁**：Go 二进制 57.3MB，单测 4 项过（T5）
- **测评推迟**：S4（s8_sprobe_r12.py 探针 A-E）与 S5（GAIA #13 + testB 重放）按用户令推迟至下一轮
- **环境换代**：旧容器死亡三现（坑#50）→ 现役 **Colab T4 单卡**；信封通道 = aitun.cc **GVMHKJCU**（v=1 协议，§四）；token 只运行时注入，推送前 grep 断言（hf_/ghp_ 字面量零容忍）

下一轮执行序（用户已令，按序）：
1. **量化先行**：T4 上 4bit + 混合 4/8bit。部署链**只用修正版 `r12_deploy_r10.py`**（r12_pipeline.py 的 S3 有旗标双前缀 bug 勿碰，坑#65）：merge→convert→手术 v2（f16 元数据，r12_surgery.py）→4x8 混合量化→推 GGUF，约 1.5h CPU 活，nohup 后台跑
2. **第一时间推** colab_t4 专用 CUDA 编译资产 + 量化权重（用户点名优先）
3. **serving 拉起** → aitun.cc 出 OpenAI 兼容 llmapi（key=1234）→ 用户实测 4bit m13_r10 效果
4. **T4 5h 预算**：资产回拉 30min（base ~18G 最先并行点火）｜量化 1.5h｜serving+API 30min（并行）｜余量充足；16G 显存带 6-7G 量化盘 ≈15-20 tok/s
5. **三纪律**：下载最先并行点火 / 部署链后台 nohup / 证据增量推

### 十一甲、历史状态存档

**R8 收尾轮（I39QPZCP 时期，v4.4 存档）**——R8 轮（两振出局+思维链纪律入训）已收官，R9=新容器收尾+实测终审：
- **R8 训练**: samples_r8.jsonl 235 窗(core88+B0截30+R7旧147, antiloop2_build.py 173 纠偏窗) → 65 步 train_loss **0.3648**(R7=0.5166), 零 NAN; think 目标含用户原话逐字"不行，我不能再无意义重复，得换一个方法和思路"; 快照 m13_r8 242M 训练完 10s 内自动推仓
- **探针终局 A/B/C=PASS**(probe_r8.py: 两振出局拒绝重复且换路/一振警觉即换工具/无退化) → 用户授权"没问题就merge推送"条件成立
- 旧容器到期, 20/20 资产抢推 hf://tchbcb/samai-8b-M8/artifacts/m15_{scripts,samples,reports}/
- **新容器 I39QPZCP 复活实录**(v4.4 坑全靠这轮踩出): token 注入 → boot_ammo_r8.py 弹药全下(S/W/C/B/G 五旗标) → ①CUDA serving: tar 包缺件(#52)→现场编译(#51/#52) ②deploy: transformers 升级(#53)+peft/torchao(#54)+借壳手术(§八甲) ③zagent: go 私仓鉴权(#55)+注入补丁器(#56)
- **公开弹药库 tchbcb/samai-9b**(新): train.md + merged_m13_r8_hf(18G fp16) + m13_r8 LoRA + m13_r8_q4_k_m.gguf + mmproj + llama_cpp_cuda_t4_v2.tar.gz(现场编译完整版) + zagent_fixed.tar.gz — T4 拉取即跑推理, README 留空
- 执行序: deploy 完成(merge✅→convert✅→quantize 等 LCBUILD 产物) → 推 Q4 → 换装 m13_r8 Q4 → GAIA #13(gold=0.00033) 同题实测死环率 = R8 根治终审
- 待办移交: GAIA 实测判分; lproj1 基线; #13 方向偏差复盘(分母=Wikipedia 全种群); 反环补丁参数调优

**M15 时期（2×T4，v4.2/v4.3 存档）**——M15 新容器已全链复活：
- BOOT1-6 全完成；GAIA gated repo 已授权并落地（165 题, L3 附件 7/7 在位）
- serving **262144 总池/parallel2=每槽131K**（坑#41 修正）+ 视觉在线；zagent online（:8384）
- M15 脚本套件已重建并推私仓 scripts/
- GAIA L3 首轮实战教训：g3a(#19) 66K 撞 65536 槽上限 HTTP 400（续作保进度成功）→ server 升 262144；g3b/c 陷入 web_search 404 狂暴环 → 截停换新卷（内嵌禁用注记, 实测 0 误调）
- 执行序（死环根治轮 v4.2 刷新）：g3a/g3b2 长磨 243/205 消息后确诊确定性死环 → 硬 stop + 短上下文新卷收官（g3a2 代码级强制令读表收官链路完整 / g3b3 死环复发硬停, 坑#44）→ 6 环捕获→13 反死环窗（§七甲）→ 147 窗 → **R7 爆发 35 步 TRAIN_DONE loss 0.5166**（m13_r6→m13_r7, 09:56）→ §八部署链已点火（m13_r7_q4_k_m.gguf）
- 部署完成后：换装 m13_r7 → lproj1 基线（65min, 目标 <10min）+ GAIA 同型题复测（观察死环根治效果: 环发生率/早断率/配额服从率）+ #13 补发验证
- v4.2 后续实测（死环根治轮收官）：m13_r7 换装上线（262144 池/12s 加载）→ #13 实测暴露 R7 微调未根治（g3c2 复合周期-2 环复发）→ **zagent 框架级反环补丁上线**（坑#47/#48 两坑三修，web_stream.go+agent.go 四处）→ g3c3 实战 6 连拦 → g3c4 短上下文收官（0.03488，fail 但闭环）→ M15 判分终局 0/3（如实记录）
- 待办移交：lproj1 基线未跑；#13 方向性偏差根因（分母应取 Wikipedia 全种群非 CSV 344）待复盘；反环补丁参数（阈值 3/重置规则）可调优


## 十二、R13/R14 战报与当前状态（2026-09-25 · 8RF5ST7K 公网 serving 全绿）

### 十二甲、R13 量化战报（GSQ-RCO-lite）

用户否决 mixbit_4x8（"量化技术不好"）后, 参考 GSQ（Gumbel-Softmax Quantization, arXiv 2604.18556）
与 RCO（arXiv 2605.00649, ISTA-DASLab）自适配为 **GSQ-RCO-lite 四段链**:
链重建 → imatrix 校准（q8 路线, ppl 5.0709）→ DP 背包逐张量类型分配 → --imatrix+类型表容器量化。

成品（tchbcb/samai-9b, 全量/抽块 sha256 与容器盘内 serving 副本比对一致）:

| 文件 | 体积 | ppl | sha256 前 16 |
|---|---|---|---|
| m13_r10_gsqrco_v1.gguf（精炼版, **serving 现役**） | 6.482G | **7.99**（旧 mixbit 8.11） | 23a73197243cb9bd |
| m13_r10_gsqrco_container_q40.gguf（A/B 副本） | 6.482G | 7.84 | 28ad41308f373cc3 |
| mmproj_m11.gguf（视觉塔, 血统链视觉冻结故持续兼容） | 921.7M | — | d89c4bc142d02ed6 |
| m13_r10_lora.gguf（R13 重烘焙; 按 git 史 9/24 新者为准覆盖 9/23 旧版） | 232.8M | — | f31236e81f547c95 |

两成品为不同文件（全量 sha256 相异, 稀疏差异=精炼只覆写部分张量）, A/B 对比有效;
ppl 差异（7.99 vs 7.84）存在度量对齐问题, 以用户实测为准。

### 十二乙、R14 serving 与公网调用（现役配方）

- **serving**: llama-server（/tmp/lcfin）`-m m13_r10_gsqrco_v1.gguf --mmproj mmproj_m11.gguf
  --host 0.0.0.0 --port 8101 --api-key 1234 -c 131072 -fa on -ctk q8_0 -ctv q8_0 -t 2 -ngl 99`
  （双 T4; 单卡 ctx 梯子 65536→32768）; 冒烟 35.9 tok/s, 租金额域题 48,000 元正确
- **公网调用（单隧道双功能, key=1234）**: `https://aitun.cc/8RF5ST7K/v1/chat/completions`
  （OpenAI 兼容, /v1/models、chat、SSE 流式全绿）
  - 原理: kaggle_server.py 注入 `/v1/*` → 127.0.0.1:8101 代理补丁
    （补丁源: tchbcb/samai-8b-M8:artifacts/r14_scripts/r14_v1_proxy.py; 坑#67/#68）
  - 隧道本体不动: aitun-client -s aitun.cc:6639 -p 5000 → kaggle_server:5000
    （/execute 信封协议 v=1 不变, §四）
  - 备选形态: 无 kaggle_server 的容器 → `aitun -p 8101` 直连隧道（oneclick 自动选择）
- **一键运行**: `python3 oneclick_gsqrco_serve.py --token hf_xxx`（本仓根目录）
  → 拉 6.48G+921M+tar → llama-server → 隧道适配 → 打印 curl/openai 调用示例;
  日志 /tmp/k8b/oneclick.log, 旗标 ONECLICK_DONE/ONECLICK_FAIL
- **A/B 切换**: 盘内 /tmp/k8b/ 两成品均在（r13_container_q40.gguf 为容器版盘内名）,
  pkill llama-server 后换 -m 路径重启即可（ctx 梯子照旧）
- 推迟项: S4 探针（s8_sprobe_r12.py A-E）+ S5（GAIA#13 复测 + testB 重放）按用户令顺延

### 十二丙、隧道运维要点（aitun.cc）

- 免 token 隧道: `aitun-client -s aitun.cc:6639 -p <本地端口>` → 自动分配码
  （同机重连保码; 跨机/新实例换码）; **真双隧道需 -k 账户 token**（坑#67）
- 监督环: jupyter kernel 自动重生 aitun 客户端与 kaggle_server（勿手工抢端口, 坑#68）
- 测试信封（隧道通用）: crc=9e30c354, payload 行 `cHJpbnQoNDArMik`（print(40+2)）,
  回显 42=全链通
- 隧道死亡史: GVMHKJCU→044WF3NQ→QCF8P0OM→FNH0ITO4（判死, 坑#50 六现）→
  **8RF5ST7K 现役**（同容器复活, 资产零损）
- 远端弹药库: tchbcb/samai-8b-M8:artifacts/r14_scripts/（r14_boot / p_r14_fire /
  p_r14_poll / router_8102 / r14_v1_proxy / oneclick 同款）