dsh-fast-mode 1.5.27 → 1.5.29

package/BENCHMARK.md

@@ -6,6 +6,26 @@
 >
 > **口径（1.5.1 起）**：一个单元只在 `exit == 0 && 步数 ≥ 1 && 输出 > 0 && 判分完成 && 未泄漏` 时计数；运行崩溃的单元整格作废并点名，不算红、也不算快。所以「全绿」一律指**有效单元全绿**（1.5.1 29/29、W5 19/19、W7 17/17）。
 
+## 提醒投递的稳定性（2026-10-29）：压缩重入会让同一轮收到两条
+
+`bench/turns.py` 按 `turn/start` 切轮，把「够长却没收到提醒」「同一轮收到两次以上」「后续轮是否重新上膛」从会话记录里数出来，不看墙钟、不看主观印象。
+
+72 小时窗口、68 个真实桌面会话、1446 轮（`--dir='--Users-*' --since-hours 72`）：
+
+| 指标 | 读数 |
+| --- | --- |
+| 合格轮（≥ 4 步） | 647 |
+| 收到压缩提醒 | 646（**99.8 %**） |
+| 同一轮收到 ≥ 2 条 | 114 |
+| 其中两次之间夹着 `compaction` | **105（92 %）** |
+| 多轮会话后续轮重新上膛 | 599 / 600 |
+
+前两行说明闸门本身没有漏投；最后一行说明「每轮重新上膛」是真的在工作。问题只在第三行：**轮内上下文压缩之后，同一轮会再收到一次同一条提醒**。
+
+根因在宿主侧的重入：压缩时该轮没有结束，宿主用**同一个 turn 号**再次进入（`turn/start` 不落盘，所以只会在插件的事件流里看到）。`noteTurn` 原先只要看到 `turn/start` 就清空每轮闩锁，`disciplineSent` 被复位，所以压缩后第 4 步又发一次。
+
+1.5.28 用 turn 号判别：同号 = 续跑，不清闩锁、不清计数器；号变大才是新轮。事件流没有 turn 号时保持旧行为。压缩后本就有独立的 reassert 提醒，所以压掉这条重复提醒不降低纪律覆盖。
+
 ## 1.5.1 干净重基线（2026-10-26）：10 家族 30 个单元，总墙钟 0.72×、逐格中位 0.64×、隐藏测试 60/60 全绿
 
 1.5.0 那一节的数字（0.86× / 0.95× / 0.85×）因两个测量缺陷整体撤回，这一节是修好缺陷之后、用当前默认（`def15`，即插件 `enabled: true` 的出厂配置）重跑的结果。**这是 1.5.x 唯一的速度声明。**

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.5.29（1.5.28 的补丁：把 `bench/turns.py` 真的放进包里）
+
+- `package.json` 的 `files` 是一份白名单，1.5.28 新增的 `bench/turns.py` 没进去：`npm pack dsh-fast-mode@1.5.28` 里没有这个脚本，而 `CHANGELOG` 和 `bench/README.md` 都在教读者运行它。1.5.29 只改白名单 + 版本号，**代码与 1.5.28 逐字相同**。
+- 复核方式：`npm pack dsh-fast-mode@1.5.29 --silent` 解包后应同时看到 `package/bench/turns.py` 与 `package/index.js` 里的 `VERSION = '1.5.29'`。
+
+## 1.5.28（稳定性：压缩后同一轮里不再重复发同一条提醒）
+
+- **先量后改**：新增 `bench/turns.py`，把留存会话按 `turn/start` 切成轮，统计「够长却没收到提醒」「同一轮收到两次以上」「多轮会话里后续轮是否重新上膛」。72 小时窗口 68 个会话 / 1446 轮：647 个合格轮**646 个收到**提醒（99.8 %）、后续轮重新上膛 599/600；但**同一轮收到两次的有 114 轮**，其中 **105 轮（92 %）两次之间夹着一次上下文压缩**。
+- **根因**：轮内压缩时宿主重入该轮（同一 turn 号再走一次 `turn/start`），`noteTurn` 把它当新轮清空了全部每轮闩锁，`disciplineSent` 被复位，于是第 4 步发过的提醒在压缩后第 4 步又发一次。
+- **修复**：`noteTurn` 接受宿主给的 turn 号，**只在新 turn 号变大时清闩锁**；同号视为续跑，计数器与闩锁全部保留（`src/auto.js`、`index.js` 传 `event.data.turn`）。事件流不带 turn 号时退回旧行为，不会更差。压缩后本来就有独立的 reassert 提醒，所以这里压掉重复的那一条不影响纪律覆盖。
+- **测试**：新增「续跑的轮保住闩锁、新轮重新上膛、无 turn 号仍按旧行为」用例；`node --test test/*.test.js` **305/305**，`style-lint` 0。
+- **没有行为变更**：默认值、提醒时机、提示词与 1.5.27 完全一致；这是投递去重，不是新旋钮。
+
 ## 1.5.27（把闸门最后两个没测过的任务族补上：方向相反，时点类旋钮收档）
 
 - **补测：`bench/suite-run.py --tasks ledger,shellpipeline --arms def15,d2g --pairs 3 --tag D2G2`**（12 次运行、全部可用、丢弃 0、质量零倒退）。`d2g` 的闸门常量（第 1 步 ≥2 次调用才提前）此前只在 `codeimpl`/`debugfix`/`migrate` 三族验过，`ledger`/`shellpipeline` 一个数都没有。

package/bench/README.md

@@ -136,6 +136,19 @@ node bench/verify-arm-reminders.mjs --arms                # 臂 x 场景的提
 
 采集方式：跑这一格时把臂补丁另存为 `<tag>.arm.yml` 并加 `debug: true` + `debugFile: <runs>/<tag>.debug`，跑完从调试日志里按 `step=N ... turnSteps=M ... directive=kind` 抽行，然后删掉日志与补丁。`debug` 只在步边界写一行已经格式化好的文本，不参与任何调度判断、不额外发请求；日志写在 run 目录之外，所以 `leak_scan`/session id 统计不受影响。老 result 行没有这些字段，读取方一律用 `.get()`，缺字段等于「没有证据」，不是「零提醒」。
 
+### 提醒是否每轮重新上膛、且每轮只发一次
+
+`bench/turns.py` 读留存会话，按 `turn/start` 切轮，输出：轮数/会话、合格轮（默认 ≥ 4 步）、**没收到提醒**的合格轮、**收到两次以上**的轮、多轮会话里后续轮的重新上膛率。只有 `user/message` / `agent/inbox/spliced` / `system/message` 里的文案算投递，模型在自己正文里复述的不算。
+
+```bash
+python3 bench/turns.py                       # 跑批会话（默认 suite 目录）
+python3 bench/turns.py --since-hours 48      # 真实会话近 48 小时
+python3 bench/turns.py --exclude-arm nodisc  # 排除某个臂的会话后缀
+python3 bench/turns.py --min-steps 4 --json  # 只算够长的轮，机器可读
+```
+
+2026-10-29 用它量出「轮内压缩后同一轮收到两条」，据此修了 1.5.28；读数与根因见 `BENCHMARK.md` 的「提醒投递的稳定性」一节。
+
 ## 正文占比与预注册门禁脚本
 
 ```bash

package/bench/turns.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Does the late-discipline reminder re-arm per turn, and only once per turn?
+
+The reminder is a once-per-turn lever: `disciplineSent` latches it so a long turn
+is told to stop narrating exactly once, and `noteTurn` clears the latch so the
+next request in the same session is told again. Both halves are invisible in the
+wall-clock numbers — a turn that never got the reminder looks like a turn that
+ignored it, and a turn that got it twice looks like a model that keeps forgetting.
+
+This reads retained transcripts, segments them on `turn/start`, and reports:
+
+- turns per session, steps per turn;
+- turns long enough to qualify (>= 4 steps) that got **no** reminder;
+- turns that got **two or more** reminders (the latch leaking);
+- re-arm rate: in multi-turn sessions, the share of later qualifying turns that
+  were reminded again.
+
+Usage:
+  python3 bench/turns.py                  # suite sessions
+  python3 bench/turns.py --limit 100      # first 100 transcripts
+  python3 bench/turns.py --min-steps 4 --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import glob
+import json
+import os
+import subprocess
+import time
+
+SESS = os.path.expanduser('~/.dsh/sessions')
+NEEDLE = 'this turn is long enough that prose'
+# A delivered directive is a message part; the model quoting it back inside its
+# own prose is an echo, so assistant-authored text never counts as delivery.
+PLUGIN_ROLES = {'user/message', 'agent/inbox/spliced', 'system/message'}
+
+
+def transcripts(pattern, limit, exclude_arm=('off',)):
+    """Session transcripts whose run directory (the slug) is not one of `exclude_arm`.
+
+    The slug mirrors the run directory, so `...-suite-D2G2-ledger-p1-def15--`
+    identifies the arm without re-reading the YAML.
+    """
+    out = []
+    for d in sorted(glob.glob(os.path.join(SESS, pattern))):
+        name = os.path.basename(d)
+        if any(name.endswith(f'-{arm}--') for arm in exclude_arm):
+            continue
+        out.extend(glob.glob(os.path.join(d, 'session-*', 'session.v4.jsonl.zstd')))
+    return out[:limit] if limit else out
+
+
+def text_of(data):
+    msg = data.get('message') or data
+    parts = msg.get('content') if isinstance(msg, dict) else None
+    if not isinstance(parts, list):
+        return ''
+    return ' '.join(p.get('text') or '' for p in parts
+                    if isinstance(p, dict) and p.get('type') == 'text')
+
+
+def scan(path):
+    """Return (started_ms, turns) for one transcript, or None if unreadable."""
+    p = subprocess.run(['zstd', '-dc', path], capture_output=True)
+    if p.returncode != 0:
+        return None
+    started = 0
+    turns = []
+    cur = {'steps': 0, 'reminders': 0, 'reminderSeqs': [], 'compactions': [],
+           'reminderSteps': []}
+    for line in p.stdout.decode('utf-8', 'replace').splitlines():
+        if ('turn/start' not in line and 'step/start' not in line
+                and 'Auto schedule' not in line and 'compaction/start' not in line):
+            continue
+        try:
+            o = json.loads(line)
+        except Exception:  # noqa: BLE001 - a torn line is not fatal
+            continue
+        kind = o.get('type')
+        data = o.get('data') or {}
+        if not started and isinstance(o.get('time'), int):
+            started = o['time']
+        if kind == 'turn/start':
+            if cur['steps'] or cur['reminders']:
+                turns.append(cur)
+            cur = {'steps': 0, 'reminders': 0, 'reminderSeqs': [], 'compactions': [],
+           'reminderSteps': []}
+        elif kind == 'step/start':
+            cur['steps'] += 1
+        elif kind == 'compaction/start':
+            cur['compactions'].append(o.get('seq'))
+        elif kind in PLUGIN_ROLES and NEEDLE in text_of(data):
+            cur['reminders'] += 1
+            cur['reminderSeqs'].append(o.get('seq'))
+            cur['reminderSteps'].append(cur['steps'])
+    if cur['steps'] or cur['reminders']:
+        turns.append(cur)
+    return started, turns
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--limit', type=int, default=0, help='transcripts; 0 = all')
+    ap.add_argument('--dir', default='--*dsh-runs-suite-*')
+    ap.add_argument('--min-steps', type=int, default=4)
+    ap.add_argument('--json', action='store_true')
+    ap.add_argument('--exclude-arm', action='append', default=[],
+                    help='skip sessions whose run directory ends in this arm (default: off)')
+    ap.add_argument('--explain-doubles', action='store_true',
+                    help='list every turn that got two reminders, with seqs and compactions')
+    ap.add_argument('--since-hours', type=float, default=0,
+                    help='only sessions started within this many hours')
+    a = ap.parse_args()
+
+    sessions = turns_total = multi = 0
+    qualifying = reminded = 0
+    misses = doubled = doubled_compacted = 0
+    later_qualifying = later_reminded = 0
+    per_session_turns = collections.Counter()
+    entry_steps = collections.Counter()
+    offenders = []
+    cutoff = (time.time() - a.since_hours * 3600) * 1000 if a.since_hours else 0
+    skipped_old = 0
+    for f in transcripts(a.dir, a.limit, tuple(a.exclude_arm or ['off'])):
+        r = scan(f)
+        if not r:
+            continue
+        started, turns = r
+        if cutoff and started and started < cutoff:
+            skipped_old += 1
+            continue
+        if not turns:
+            continue
+        sessions += 1
+        turns_total += len(turns)
+        per_session_turns[len(turns)] += 1
+        if len(turns) > 1:
+            multi += 1
+        for i, t in enumerate(turns):
+            if t['steps'] >= a.min_steps:
+                qualifying += 1
+                if t['reminders']:
+                    reminded += 1
+                else:
+                    misses += 1
+                if i > 0:
+                    later_qualifying += 1
+                    later_reminded += 1 if t['reminders'] else 0
+            if t['reminders']:
+                entry_steps[t['reminderSteps'][0]] += 1
+            if t['reminders'] > 1:
+                doubled += 1
+                seqs = t['reminderSeqs']
+                if any(c is not None and seqs and seqs[0] < c < seqs[-1] for c in t['compactions']):
+                    doubled_compacted += 1
+                if a.explain_doubles:
+                    offenders.append({
+                        'session': os.path.basename(os.path.dirname(os.path.dirname(f))),
+                        'turn': i + 1,
+                        'steps': t['steps'],
+                        'reminderSeqs': seqs,
+                        'reminderSteps': t['reminderSteps'],
+                        'compactions': t['compactions'],
+                    })
+
+    out = {
+        'sessions': sessions,
+        'turns': turns_total,
+        'multi_turn_sessions': multi,
+        'turns_per_session': dict(sorted(per_session_turns.items())),
+        'min_steps': a.min_steps,
+        'qualifying_turns': qualifying,
+        'reminded': reminded,
+        'missed': misses,
+        'doubled': doubled,
+        'doubled_with_compaction_between': doubled_compacted,
+        'entry_steps': dict(sorted(entry_steps.items())),
+        'later_qualifying_turns': later_qualifying,
+        'later_reminded': later_reminded,
+        'skipped_old': skipped_old,
+        'since_hours': a.since_hours,
+    }
+    if a.json:
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+        return
+    print(f"sessions {sessions}  turns {turns_total}  multi-turn {multi} "
+          f"({100 * multi / max(sessions, 1):.0f} %)")
+    print(f"turns per session: {dict(sorted(per_session_turns.items()))}")
+    print(f"qualifying turns (>= {a.min_steps} steps) {qualifying}  "
+          f"reminded {reminded} ({100 * reminded / max(qualifying, 1):.0f} %)  "
+          f"missed {misses}  doubled {doubled} "
+          f"(with a compaction between: {doubled_compacted})")
+    if entry_steps:
+        print(f"first reminder landed at step: {dict(sorted(entry_steps.items()))}")
+    if a.explain_doubles and offenders:
+        print('doubled turns:')
+        for o in offenders[:20]:
+            print(f"  {o['session']} turn {o['turn']} steps {o['steps']} "
+                  f"reminders at steps {o['reminderSteps']} seqs {o['reminderSeqs']} "
+                  f"compactions {o['compactions']}")
+    print(f"later turns in multi-turn sessions: qualifying {later_qualifying}  "
+          f"reminded {later_reminded} "
+          f"({100 * later_reminded / max(later_qualifying, 1):.0f} %)")
+
+
+if __name__ == '__main__':
+    main()

package/index.js

@@ -97,7 +97,7 @@ const TAG = '[fast-mode]'
  * Shipped identity of this build. Traced into the debug log so a stale install is
  * visible at a glance, and pinned by a test against `package.json`.
  */
-export const VERSION = '1.5.27'
+export const VERSION = '1.5.29'
 const GLOBAL_AGENT = '__global__'
 
 /**
@@ -326,7 +326,10 @@ export function apply(ctx, rawConfig) {
     }
     if (event && event.type === 'turn/start') {
       try {
-        noteTurn(auto, agentKey(session))
+        // The turn number is what separates a real new turn from the harness
+        // re-entering a turn it compacted mid-flight: the latter must not reset
+        // the per-turn latches, or the model gets the same reminder twice.
+        noteTurn(auto, agentKey(session), event.data?.turn ?? event.turn)
       } catch {
         // A scheduler that can fail a turn is worse than no scheduler.
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fast-mode",
-  "version": "1.5.27",
+  "version": "1.5.29",
   "description": "DeepSeek Harness fast mode: same thinking effort, fewer round trips. An adaptive parallel tool fan-out, output discipline that never trims the answer, and a cancellable stall guard. Never changes reasoning effort, the model, or the request body. Provider-agnostic, one dependency (@deepseek-ai/schemastery).",
   "repository": {
     "type": "git",
@@ -44,6 +44,7 @@
     "bench/reminders.py",
     "bench/patchshare.py",
     "bench/ablate.py",
+    "bench/turns.py",
     "docs/",
     "LICENSE"
   ],

package/src/auto.js

@@ -200,6 +200,8 @@ function entryOf(state, agent) {
   }
   entry = {
     steps: 0,
+    /** The harness turn number this entry's latches belong to; 0 = unknown. */
+    turn: 0,
     turnSteps: 0,
     noProgress: 0,
     calls: 0,
@@ -309,11 +311,25 @@ function entryOf(state, agent) {
  * session-level memory (what has already been tried) must survive, because that
  * is exactly what a stuck loop re-reads.
  *
+ * A turn that is *resumed* — mid-turn context compaction makes the harness
+ * re-enter the turn without ending it — must not get the slate: resetting here
+ * would clear `disciplineSent` and hand the model the same "prose is the cost"
+ * reminder a second time in the same turn (measured: 227 turns with a doubled
+ * reminder in retained transcripts, 214 of them with a compaction between the
+ * two). The turn number is the discriminator: same number as the entry's current
+ * turn means resume, larger means a real new turn. `0`/absent keeps the old
+ * behaviour, so an event stream that omits the number is never worse off.
+ *
  * @param {ReturnType<typeof createAutoState>} state
  * @param {string} agent
+ * @param {number} [turn] the harness turn number from `turn/start`
  */
-export function noteTurn(state, agent) {
+export function noteTurn(state, agent, turn) {
   const entry = entryOf(state, agent)
+  if (typeof turn === 'number' && Number.isFinite(turn) && turn > 0) {
+    if (entry.turn === turn) return
+    entry.turn = turn
+  }
   entry.turnSteps = 0
   entry.stepCalls = 0
   entry.stepUnsafe = 0