dsh-fast-mode 1.5.30 → 1.5.31

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.5.31（`turns.py` 顺手审另一条提醒：压缩后重述规则的那条，会不会无理由地多出来）
+
+- 插件只主动发两条提醒：入场步的「少写散文」（每轮恰好一次）和压缩后的「规则重申」（每次压缩后一次，因为规则可能被裁掉）。`bench/turns.py` 原来只审第一条，第二条只当噪音忽略——如果它的标志位泄漏，就会在每个合格轮里白送一段规则文本。
+- 新增读数：有多少轮带过重述、其中有多少轮的重述条数**超过**该轮的压缩次数 + 1（+1 是允许的：压缩发生在上一轮末尾时，重申落在下一轮第一步）。近 72 小时真实会话：**624 轮**带重述，**0 轮**没有压缩可指。
+- 同时把「首次提醒落在第几步」的直方图、`--explain-doubles`（列出每个重复提醒的轮、步号、seq 与压缩点）固化进脚本，方便下次换版本时重跑对照。
+- 只动 `bench/turns.py` 与文档，`src/` 无改动。
+
 ## 1.5.30（把 1.5.28 的修复拿真实流量做 A/B：同一份会话，同一串事件，两个版本）
 
 - **新增 `bench/replay.mjs`**：把一份留存会话的事件流原样喂给插件自己的钩子（`session/event` + `agent/pre-step`），数出「这一版会发几条提醒、落在第几步」。会话 id 是合成的，`metrics`/`benchmarkFile` 关掉，不碰 `~/.dsh` 状态。

package/bench/README.md

@@ -146,6 +146,8 @@ node bench/replay.mjs <transcript> --json
 node bench/replay.mjs <transcript> --simulate-reentry   # 每次压缩后按当前 turn 号重入
 ```
 
+`turns.py` 同时审两条提醒：入场步的「少写散文」（每轮恰好一次）与压缩后的「规则重申」（每次压缩后一次）。后者允许比该轮压缩次数多一条（压缩发生在上一轮末尾时重申落在下一轮第一步），超过就是标志位泄漏；近 72 小时真实会话是 624 轮带重申、0 轮无压缩可指。`--explain-doubles` 会逐条列出重复提醒所在的轮、步号、seq 与压缩点。
+
 `--simulate-reentry` 补的是会话记录里**不存在**的那条事件：宿主压缩后重入同一轮时用同一个 turn 号再发一次 `turn/start`，而这次重入不落盘。加上它以后，1.5.27 与 1.5.28 的差别就能在同一份数据上量出来（1529 个合格轮：940 → 0）。
 
 ### 提醒是否每轮重新上膛、且每轮只发一次

package/bench/turns.py

@@ -33,6 +33,11 @@ import time
 
 SESS = os.path.expanduser('~/.dsh/sessions')
 NEEDLE = 'this turn is long enough that prose'
+# The other notice the plugin can deliver, the one that restates the rules after a
+# compaction. It is *supposed* to repeat, once per compaction whose rules were
+# evicted; the audit question is only whether it ever fires with no compaction to
+# point at, which would mean a stale flag.
+REASSERT = 'the context was just compacted'
 # 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'}
@@ -70,10 +75,11 @@ def scan(path):
     started = 0
     turns = []
     cur = {'steps': 0, 'reminders': 0, 'reminderSeqs': [], 'compactions': [],
-           'reminderSteps': []}
+           'reminderSteps': [], 'reasserts': 0}
     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):
+                and 'Auto schedule' not in line and 'compaction/start' not in line
+                and 'context was just compacted' not in line):
             continue
         try:
             o = json.loads(line)
@@ -87,11 +93,13 @@ def scan(path):
             if cur['steps'] or cur['reminders']:
                 turns.append(cur)
             cur = {'steps': 0, 'reminders': 0, 'reminderSeqs': [], 'compactions': [],
-           'reminderSteps': []}
+                   'reminderSteps': [], 'reasserts': 0}
         elif kind == 'step/start':
             cur['steps'] += 1
         elif kind == 'compaction/start':
             cur['compactions'].append(o.get('seq'))
+        elif kind in PLUGIN_ROLES and REASSERT in text_of(data):
+            cur['reasserts'] += 1
         elif kind in PLUGIN_ROLES and NEEDLE in text_of(data):
             cur['reminders'] += 1
             cur['reminderSeqs'].append(o.get('seq'))
@@ -121,6 +129,7 @@ def main():
     later_qualifying = later_reminded = 0
     per_session_turns = collections.Counter()
     entry_steps = collections.Counter()
+    reasserted = reassert_orphan = 0
     offenders = []
     cutoff = (time.time() - a.since_hours * 3600) * 1000 if a.since_hours else 0
     skipped_old = 0
@@ -151,6 +160,12 @@ def main():
                     later_reminded += 1 if t['reminders'] else 0
             if t['reminders']:
                 entry_steps[t['reminderSteps'][0]] += 1
+            if t['reasserts']:
+                reasserted += 1
+                # One reassert belongs to a compaction from the previous turn: the
+                # flag is set, the turn ends, the next step of the next turn speaks.
+                if t['reasserts'] > len(t['compactions']) + 1:
+                    reassert_orphan += 1
             if t['reminders'] > 1:
                 doubled += 1
                 seqs = t['reminderSeqs']
@@ -178,6 +193,8 @@ def main():
         'doubled': doubled,
         'doubled_with_compaction_between': doubled_compacted,
         'entry_steps': dict(sorted(entry_steps.items())),
+        'turns_with_compaction_reassert': reasserted,
+        'reasserts_without_compaction': reassert_orphan,
         'later_qualifying_turns': later_qualifying,
         'later_reminded': later_reminded,
         'skipped_old': skipped_old,
@@ -195,6 +212,8 @@ def main():
           f"(with a compaction between: {doubled_compacted})")
     if entry_steps:
         print(f"first reminder landed at step: {dict(sorted(entry_steps.items()))}")
+    print(f"compaction re-assert: {reasserted} turns carried one, "
+          f"{reassert_orphan} had more of them than compactions to point at")
     if a.explain_doubles and offenders:
         print('doubled turns:')
         for o in offenders[:20]:

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.30'
+export const VERSION = '1.5.31'
 const GLOBAL_AGENT = '__global__'
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fast-mode",
-  "version": "1.5.30",
+  "version": "1.5.31",
   "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",