[Bug] 思考通道（reasoning）退化：中文思考下「最短独立句」自我复制，flash 系易发

[dleaf6211-hash]

（拟接官方既有讨论：#4841「正文输出 000000」、#3480「repetition guard 提议」）

================================================================
一、摘要

DeepSeek Harness + deepseek-vision 渠道 + flash 系模型 + 中文思考时，思考块会退化成「能独立成句的最短单元」的自我复制——中文单字（好。好。好。）或英文行动 token（Go. Go. Go.）。严重时整块约 99% 是单字、正文被吞、会话走到失能。换成 v4-pro 后同一环境、同一中文思考下症状消失。

与 #4841（正文输出 000000）、ollama #17892（正文段落复读 221 次）同属「最短独立句自复制」，但本案发生在思考通道（reasoning），而 #3480 的守卫默认忽略 reasoning。

---

英文摘要（English Abstract）

Under the deepseek-vision channel with flash-tier models, when the model's reasoning language (the thinking channel, rather than the output text) is Chinese, the thinking block degenerates into self-replication of the shortest standalone sentence — single Chinese characters (好。好。好。) or English action tokens (Go. Go. Go.). In severe cases up to ~99% of one block consists of a single repeated character, the reply can be swallowed, and the session becomes unresponsive. Switching to v4-pro under otherwise identical conditions makes it disappear. This is the same "minimal-standalone-sentence replication" as reported in #4841 (text-channel 000000) and #17892 (text-channel paragraph repetition), but it occurs in the reasoning channel — which #3480's guard ignores by default.

================================================================
二、现象（两型）

【A 型 · 收尾简写】

• 位置：块尾
• 语言：中文
• 例子：写。 / 跑。 / 做。 / 好。
• 特征：句尾习惯塌缩成单字，可无限接龙

【B 型 · 行动催促】

• 位置：工具调用前
• 语言：英文跳变
• 例子：Go. / Emit now.
• 特征：中文思考在行动决策点漏出英文 token，几乎 100% 与工具调用共现

================================================================
三、复现

环境：deepseek-vision 渠道 + deepseek-flash / deepseek-v4-flash + 思考语言 = 中文 + 长会话（跨天 / 有上下文压缩更易发）。

触发链：会话【第一段】被中文锚定（例如首条消息写「请用中文思考」）→ 中文思考 → 句尾单字化 → 单字循环（严重时可能伴随内吞；二者是否同因待查，见「噪音与吞是独立故障」）。

抑制：换 deepseek-v4-pro（其余变量全不变）→ 单字当场消失（实测）。

================================================================
四、判据（可复现量化；工具已随双机工作区同步，可随附提供）

判据一 · 块尾单字率（short block-tail rate，≤2 字符的块尾片段占比）

• 病态 / 过渡：57–62%
• 干净中文会话：11%
• 英文思考：0%
• 警惕线：≥30%

判据二 · LRS（longest repeated fragment run，最长连续相同片段游程）

• 病态：176 / 7298
• 干净中文 / 英文：1–2
• 警惕线：≥3（须排除纯标点，代码块右花括号 } 会假阳性）

================================================================
五、机理（五条）

1. 思考语言 ≠ 输出语言；语言在「新 turn 第一段」锁定，turn 中途重申无法改回（Reasonix PR [Bug] Two concurrent owners corrupt one session log, then the whole history fails to load with a misleading "torn JSONL record" error #6500 实测 0/4）。

2. 最短独立句复制是语言无关的：中文塌成「好。」、英文塌成「Let me go.」，同一机制两张皮。全机验证「Let me go.」独立成句块数：

   • a638c624（flash）：42 块，42/42 带工具
   • c4c60f4e（v4-flash）：37 块，36/37 带工具
   • 20c114f9（v4-flash）：17 块，17/17 带工具
   • e9bffca1（v4-flash）：17 块，17/17 带工具
   • d234f329（v4-pro）：1 块，1/1 带工具
   • 65bfa370（v4-pro）：0 块
     （flash 系合计 113 次、99% 带工具；pro 631 块仅 1 次——机理 4 的直接量化）

3. 单 token 吸子：复读 = 自回归吸子。6c3117db 三阶段实拍：混战（执行/好/Emit/go. 交替）→ 连续 6 桶 100%「好」→ LRS 75→7298。外部注入（工具结果 / 新消息）= 破吸子，因此理论上不需熔断，检测 + 打断注入即可。

4. flash 易感：pro 也用最短句但「用而不塌」，flash「用而塌缩锁定」（活跃参数按官方 V4 Preview 规格：Flash 13B / Pro 49B）。

5. 通道转移：英文思考病发正文（输出了大量异常内容，浪费我token #4841 / #17892），中文思考病发思考（本案）。

================================================================
六、双机数据（两机工具输出一致，判据可复现）

• 6c3117db（家机 / flash / 中文 88%）：块尾单字率 62%，LRS 7298 → 会话失能（思考块 99% 单字化、无法继续；内部等级 L4）
• c4c60f4e（家机 / v4-flash / 中文 53%）：单字率 4%，LRS 176 → B 型（Go.×238）
• 49847e4b（家机 / flash→pro / 中文 94%）：单字率 57%→0，LRS 3 → 换 pro 后消失
• c7034f6b（公司机 / v4-pro / 中文 92%）：单字率 11%，LRS 2 → 干净
• 60d3e97c（公司机 / v4-flash→pro / 中文 21%）：单字率 2%，LRS 3（} 假阳性）→ 干净（注：其 flash 段仅 21:58–22:31 半小时，勿读成全会话 flash）

================================================================
七、修复建议

1. 用户侧：锁死思考语言为英文（persona 硬写，或用 dsh-thinking-lang 设 English），或换 v4-pro。
2. 官方侧：在 Detect and recover from degenerate repeated model output (repetition guard) / 检测并恢复退化的重复模型输出（重复守卫） #3480 的 llm/stream 守卫上增加思考通道（reasoning）的重复守卫（当前默认忽略 reasoning）；判据建议用「最短独立句连续复读」，比 Detect and recover from degenerate repeated model output (repetition guard) / 检测并恢复退化的重复模型输出（重复守卫） #3480 的「8 字符单元」更短——本案重复单元是 1–2 字符（单字 / 单 token）。

================================================================
八、环境

DSH 0.1.5-rc.1 / deepseek-vision 渠道 / Windows / 双机（家机 PC-20260430SMHX、公司机 DESKTOP-EF1HGIE）。

[argszero]

Thanks — this is a well-instrumented report, and the channel distinction is the part that matters. Adding what the shipped sources say, because the two repetition guards that already sit on llm/stream do not cover the shape you measured, and each has a stated reason.

The harness itself ships no repetition guard. The only degenerate occurrences under packages/llm are about empty content (llm-pi-ai/src/stream.ts:97, llm/src/error.ts:35 — a terminal stop that carried no blocks). #3480's proposal was implemented as an ecosystem plugin (dsh-llm-repetition-guard), and its own defaults are exactly the gap you are describing: text deltas guarded, reasoning deltas ignored unless opted in, and the trip condition is ≥6 consecutive repeats of an 8-character unit after 64 accumulated characters.

A second guard sits on the same seam, and it is reasoning-blind on purpose. @argszero/cordis-plugin-thinking-loop-guard (npm, MIT) wraps llm/stream; its mid-stream breaker ends a call that repeats its visible output — maxRepeatedText (identical normalized deltas) and maxRepeatedCycleChars/minRepeatedCycleChars (default: 256 characters of exact trailing periodicity, max period 64). Its detector is documented as "deliberately blind to reasoning text, which legitimately revisits itself", and in the shipped code only text-delta chunks reach it.

So your shape has no rule that can act while the call is open:

• the intra-call breaker is blind to reasoning by construction;
• the same plugin's post-call judgement does read reasoning (repeated-gram coverage, repeatRatio ≥ 0.5 over ≥ 2048 characters) — but it runs only once the call has ended, and it then needs maxThinkingSteps (default 3) consecutive stalled calls before it reacts.

That is inverted for a 99%-single-character block: the worst call is the one nothing can interrupt, and by the time the post-call rule reads it, the call has already spent its whole output budget.

Why the visible-output rule cannot simply be pointed at reasoning. Two of its guards are load-bearing for output and wrong for reasoning:

• the "period must contain ≥ 2 distinct characters" rule exists to spare divider lines (====); a genuine 1-character bleed (period 1) is therefore excluded by design — and your own data puts the repeating unit at "1–2 characters";
• minRepeatedCycleChars was calibrated against legitimately repetitive output (a 40-row markdown table scoring 0.72 coverage, generated CSS rows 0.82). Reasoning revisits itself by nature, so one shared threshold either under-fires on reasoning or truncates honest output.

On your two criteria as guard inputs. Both are corpus measures over a finished block; a mid-stream guard only ever holds a prefix, so it cannot compute a block-tail rate or an LRS. What it can use is what the visible breaker already uses: an exact periodic tail. Under that measure your A-type and B-type collapse into one rule ("好。" is period 2 with two distinct characters, "Go. " is period 4), and the measure is false-positive-free by construction on near-repeats — the reason the reasoning channel needs its own thresholds is the first bullet above, not a different algorithm.

I am adding an intra-call reasoning rule to that plugin — its own thresholds, and an explicit decision about period 1 rather than inheriting the divider rule — and will post it here when it ships. To be clear about what it is: a guard, not a fix. That v4-pro does not degrade in the same environment says the propensity is model- and tier-side; the guard's job is to stop the session from being spent on the block and to get a correction into the next turn.

[argszero]

Shipped: @argszero/cordis-plugin-thinking-loop-guard@0.2.0 — https://www.npmjs.com/package/@argszero/cordis-plugin-thinking-loop-guard (MIT, source: https://github.com/argszero/cordis-plugin-thinking-loop-guard). This is the rule I said I was adding in my previous comment, and this post is the delivery report rather than a second opinion on the diagnosis.

What it does for your shape. The plugin observes the public llm/stream waterfall and ends a single degenerate call from inside the wrapper with a terminal REPETITIVE_OUTPUT finish, which fails the step through the loop's normal error path (reachable by a retry policy at agent/request-error) and pre-queues a steering correction so the resumed turn is told what happened. Until 0.2.0 its two breakers only watched visible output; 0.2.0 adds the reasoning channel with maxRepeatedReasoningCycleChars (default 64) and minRepeatedReasoningCycleChars (default 256):

- insert:
    - id: thinking-loop-guard
      name: '@argszero/cordis-plugin-thinking-loop-guard'   # mount once; defaults are on

It runs the same scan as the visible-output rule and differs in exactly one dimension: a one-character period is admitted when the repeated character is content (a letter or a digit). That difference is your first finding restated as code — the visible rule refuses period 1 to spare ===== divider lines, and that exemption is precisely wrong for a channel whose mechanism is collapsing onto the shortest unit. Inheriting it would have left your decisive case (a single character repeated thousands of times) uncatchable while the rule appeared to cover the channel. The mirror-image miss is documented rather than papered over: a bleed of a purely punctuation character (。 repeated) is not caught, and a run of punctuation or whitespace is still read as layout, so a divider inside a thinking block is not truncated. Every other threshold is shared with the visible rule, so the two channels differ in one concept instead of a second table of tuned constants; both are separately configurable and separately disableable.

Measured, on your two shapes. Under the shipped defaults each is cut at exactly 256 characters of reasoning — your A-type's 好 at 256 deltas, the 好。 spelling of it at 128, your B-type's Go. at 64 deltas — and it fires while the call is still open, with one steering correction queued for the resumed turn. 256 is the minRepeatedReasoningCycleChars floor, and it is anchored on your own numbers rather than on taste: your clean controls measure LRS 1–2, your Go. × 238 on c4c60f4e is well clear of the floor, and on the LRS 7298 host the cut would land about 3.5% of the way into the run you measured. If your session files suggest a different cut point, both numbers are config knobs.

Your two criteria, re-read as guard inputs. Both are corpus measures over a finished block — a block-tail rate and a longest repeated run. A mid-stream guard only ever holds a prefix, so it cannot compute either; what it can use is what the visible breaker already uses, an exact periodic tail. Under that measure your A-type and B-type collapse into one rule (好。 is period 2, Go. period 4), and the measure is false-positive-free on near-repeats by construction — which is why the channel needed its own period-1 decision, not its own algorithm. One honest limit that follows: your pre-lock-in phase (执行/好/Emit/go. alternating) is not periodic, so the rule does not fire there; it fires once the tail is exactly periodic, which is the state the session does not come back from.

To check it against your own data. The package ships tools/analyze-session.mjs, which replays a session jsonl through the same decision rules and now prints a reasonCycle column per model call next to the existing repeatedRun/cycleSpan, so your 6c3117db / c4c60f4e / 49847e4b files can be replayed to see where it would have cut and where it would not. It reads the durable assistant/chunk (≤ 0.1.2-rc.1) and assistant/attempt (≥ 0.1.5) formats, and each run ends with a coverage block naming what it skipped — a zero over a file it could not parse is reported as such instead of as health.

node node_modules/@argszero/cordis-plugin-thinking-loop-guard/tools/analyze-session.mjs ~/.dsh/sessions/<session>.jsonl

What it is not. A guard, not a fix. It ends the degenerate call and steers the resumed turn; it does not stop a model from collapsing again, and it deliberately offers no fallback model and no automatic retry, because silently re-billing a degenerate model is worse than the loop. Your pro-versus-flash control is the strongest evidence for where the propensity actually lives, and this plugin is the layer that limits what a collapse costs.

Evidence. 109 tests (npm test), of which test/reasoning-breaker.spec.mjs covers the primitive, the period-1 decision, the false-positive controls (reasoning restated in different words, a markdown table, a divider line) and the apply() cut driven through the shipped @deepseek-ai/dsh-llm/invariant with a reasoning block still open — the grammar position this cut occupies, which is not the one the visible breaker uses. A mutation harness over the new rule reports 8/8 arms caught, 0 silent, including the arms that would have made it a copy of the visible rule. The published tarball was installed by name and run, not just built: under defaults it cuts the 好-repeated stream at exactly the span minimum, leaves varied reasoning untouched, and passes the invariant.