@jjh32456/dsh-longlive 1.6.6 → 1.6.7

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.6.7
+
+- 热截断加固：turn===0 / 无 turn 记录的组不再永久屏障（含 system/developer 指令的原地保留，只含普通消息的随旧前缀整组归档）；中段缺 turn/end 的轮只有最后启动的当前轮不可切；新增 onNoPlan 拒绝原因通道，切不了会写 'hot-truncate: 未切（reason）'，杜绝静默零进展。
+
 ## 1.6.6
 
 - 热截断修复：去掉 skipPast 永久钉死（aborted/interrupted 轮只要有 turn/end 就整轮可切）；段首 system/message 永不进切段，中途注入的 system 副本随旧前缀归档。修复后真实会话一次可切 35 个 closed 轮（约 46 万 tokens），上下文回到最近 4 轮量级。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jjh32456/dsh-longlive",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "type": "module",
   "description": "久视（longlive）：一个磁盘上的共享大脑，让每个会话都是同一个你——记忆卡、状态卡、开机卡让新会话接上同一段关系与未完成的事；配套会话卫生（热截断/备份/D2/D6 裁剪）与记忆工具（巩固/召回/程序性记忆）。1.6.4 修复记忆根可移植性（默认根 = <DSH home>/longlive-memory，一处配置贯穿全部落盘），并同步面板 0.2.5 文案与 G1-G4 修复。",
   "keywords": [

package/src/compaction/engine-core.js

@@ -342,21 +342,31 @@ function roughPointerTokens(text) {
 }
 
 /**
- * Select the oldest whole completed turns that sit outside the retention
- * window. Returns null when no safe cut exists (the common, expected answer).
+ * Select the oldest whole closed turns that sit outside the retention window.
+ * Returns null when no safe cut exists; every such refusal reports a structured
+ * reason through `helpers.onNoPlan` so a silently disabled hot truncate is
+ * observable (the engine logs it once per reason).
  *
- * The host protects surface position 0 when it holds the system prompt: a
- * user/message replacement may not shadow that node. This engine's contract is
- * stronger than the host's: a `system/message` is never part of a cut. The span
- * therefore starts at the first user/assistant node after every leading
- * system node, and a system node anywhere inside a candidate span is a hard
- * right boundary. Checkpoint nodes at the head of the span are folded into the
- * same cut, which keeps exactly one pointer.
+ * The leading run of `system/message` / `developer/message` nodes (the real
+ * system prompt at host-protected position 0) is never moved. A `system/message`
+ * re-injected by a host restart further inside the surface is an archived copy
+ * of that same prompt (host-tolerated inside a replacement range). Checkpoint
+ * nodes at the head of the span are folded into the same cut, which keeps
+ * exactly one pointer.
  */
 export function selectCutPlan(session, options, measurement, helpers = {}) {
   const table = helpers.table ?? turnTable(session);
   const groups = surfaceGroups(session, table, helpers.isCheckpointSource);
-  if (groups.length === 0) return null;
+  const onNoPlan = typeof helpers.onNoPlan === 'function' ? helpers.onNoPlan : null;
+  const noPlan = (reason, detail) => {
+    try {
+      onNoPlan?.({ reason, detail: detail === undefined ? null : detail });
+    } catch {
+      // Diagnostics never break a plan.
+    }
+    return null;
+  };
+  if (groups.length === 0) return noPlan('no-groups');
   const tokens = new Map();
   for (const node of measurement?.nodes ?? []) {
     if (node && typeof node.seq === 'number' && Number.isFinite(node.tokens)) tokens.set(node.seq, node.tokens);
@@ -386,29 +396,37 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
       break;
     }
   }
-  if (boundary <= 0) return null;
+  if (boundary <= 0) return noPlan('not-enough-turns', { groups: groups.length });
 
   const surfaceNodes = session?.surface?.nodes ?? [];
-  if (surfaceNodes.length === 0) return null;
+  if (surfaceNodes.length === 0) return noPlan('no-surface');
 
-  // 2026-11-06 1.6.6 hotfix — the aborted-turn freeze, second attempt.
+  // 2026-11-06 1.6.7 hardening — no permanent barrier, no silent zero progress.
   //
-  // 1.6.5 stopped an aborted/unfinished turn from returning null, but it kept
-  // the old "never cut an aborted turn" rule: the span was moved *after* the
-  // last aborted turn in the prefix. When aborted turns recur near the tail
-  // (restart-aborted / interrupted turns; real session 2026-11-06: turns 48,
-  // 74, 85, 90, 94), the last one sits right before the retention boundary, so
-  // the plan degenerates to "cut the single completed turn after it" (6–18k
-  // tokens) while every older completed turn (≈370k tokens) stays pinned in
-  // the surface as a permanent prefix. That is the exact shape of the
-  // 396k-token context.
+  // 1.6.6 removed the aborted-turn freeze but treated every group without a
+  // usable turn record as an immovable open group and stopped the span before
+  // it. Three surface shapes then made the planner return null forever even
+  // though whole closed turns older than the retention window existed:
+  //   * a log truncated mid-turn leaves orphan messages at the surface head
+  //     (no turn/start) — a turn===0 group at the head (red team E1);
+  //   * the host appends a user/message between turns — a turn===0 group in
+  //     the middle (red team E3);
+  //   * a turn whose turn/end was lost by log truncation — turn N has no
+  //     endSeq but later turns exist (red team E2).
   //
-  // A turn with a `turn/end` event is closed: it never gains new events, its
-  // tool pairs are complete by construction, and cutting it whole keeps the
-  // pairing balanced. Only a turn with no `turn/end` yet (the currently open
-  // turn, or a turn the log was truncated inside) must stay in place. So the
-  // span may now cover closed-but-not-completed turns; `cutTurnGroups` below
-  // includes them and the archive copies the full turn range via byNumber.
+  // Rules now:
+  //   * the whole LEADING run of system/message + developer/message nodes is
+  //     never moved (head instructions; host-protected position 0);
+  //   * a turn===0 group that carries a system/developer node is a head
+  //     instruction zone and stays in place; a turn===0 group of plain messages
+  //     is an orphan prefix and is archived with the cut (recoverable);
+  //   * a group whose turn has no turn/end is the CURRENT turn only when it is
+  //     the last started turn; an earlier turn without turn/end is abandoned
+  //     (the log was truncated inside it) and is cuttable, archived through an
+  //     inferred range up to the next turn/start;
+  //   * the planner skips a blocked head barrier and cuts the next run of
+  //     wholly-cuttable groups; if nothing is cuttable it reports the reason
+  //     through onNoPlan instead of returning null silently.
   const groupStart = new Array(groups.length);
   const groupEnd = new Array(groups.length);
   const groupOfPosition = new Array(surfaceNodes.length);
@@ -420,99 +438,118 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
       groupEnd[index] = cursor - 1;
     }
   }
+  const typeOfSeq = (seq) => table.bySeq.get(seq)?.type;
+  const isInstructionSeq = (seq) => typeOfSeq(seq) === 'system/message' || typeOfSeq(seq) === 'developer/message';
+  const protectedSeqs = new Set();
+  {
+    let position = 0;
+    while (position < surfaceNodes.length && isInstructionSeq(surfaceNodes[position])) {
+      protectedSeqs.add(surfaceNodes[position]);
+      position += 1;
+    }
+  }
+  const lastStarted = table.turns.length > 0 ? table.turns[table.turns.length - 1] : null;
   const turnInfoOf = (group) => (group.kind === 'turn' && group.turn !== 0 ? table.byNumber.get(group.turn) : undefined);
-  const isOpenGroup = (group) => {
+  const isCurrentTurnGroup = (group) => {
+    if (group.kind !== 'turn' || group.turn === 0) return false;
+    const info = table.byNumber.get(group.turn);
+    if (info === undefined) return true;
+    return info.endSeq === null && lastStarted !== null && info.turn === lastStarted.turn;
+  };
+  const isCuttableGroup = (group) => {
+    if (group === undefined) return false;
+    if (group.kind === 'checkpoint') return true;
     if (group.kind !== 'turn') return false;
-    if (group.turn === 0) return true;
-    const info = turnInfoOf(group);
-    return info === undefined || info.endSeq === null;
+    // A turn===0 group is either an orphan head zone (contains instructions) or
+    // a stray message block between turns; only the latter may be archived.
+    if (group.turn === 0) return !group.seqs.some((seq) => isInstructionSeq(seq));
+    const info = table.byNumber.get(group.turn);
+    if (info === undefined) return false;
+    return !isCurrentTurnGroup(group);
+  };
+  // An abandoned turn (no turn/end, but a later turn/start exists) never got a
+  // closing event; the archive range is inferred up to the next turn/start so
+  // every one of its original events stays recoverable.
+  const resolvedEndSeq = (group) => {
+    const info = table.byNumber.get(group.turn);
+    const lastSurfaceSeq = group.seqs[group.seqs.length - 1];
+    if (info === undefined || !Number.isInteger(info.startSeq)) return lastSurfaceSeq;
+    if (Number.isInteger(info.endSeq)) return info.endSeq;
+    const next = table.turns.find((entry) => Number.isInteger(entry.startSeq) && entry.startSeq > info.startSeq);
+    if (next === undefined) return lastSurfaceSeq;
+    return Math.max(info.startSeq, next.startSeq - 1);
   };
 
-  // The head of the surface is the real system prompt: the host protects
-  // position 0 and this engine keeps the whole leading run of system/message
-  // nodes in place. The span starts at the first user/assistant node after it.
+  // The span starts after the protected head run and on a user/assistant node
+  // (the pointer replaces one); a system copy skipped at the head of a turn
+  // stays outside the span exactly like 1.6.6 — it is never moved out.
   let startIndex = 0;
-  while (startIndex < surfaceNodes.length
-    && table.bySeq.get(surfaceNodes[startIndex])?.type === 'system/message') {
-    startIndex += 1;
-  }
-  // The pointer replaces a user/assistant message, so the first cut node must
-  // be one. A leading developer node is kept in place instead of cut.
+  while (startIndex < surfaceNodes.length && protectedSeqs.has(surfaceNodes[startIndex])) startIndex += 1;
   while (startIndex < surfaceNodes.length) {
-    const type = table.bySeq.get(surfaceNodes[startIndex])?.type;
+    const type = typeOfSeq(surfaceNodes[startIndex]);
     if (type === 'user/message' || type === 'assistant/message') break;
     startIndex += 1;
   }
-  if (startIndex >= surfaceNodes.length) return null;
-  // A leading group may start with the injected system prompt and continue with
-  // the turn's own nodes. The system nodes stay outside; the span starts at the
-  // first non-system node of that group — the skipped prefix is system-only, so
-  // no user/assistant/tool node is left half-cut. A group whose head contains
-  // non-system nodes is kept whole instead.
-  let startGroup = groupOfPosition[startIndex];
-  while (startGroup < groups.length && groupStart[startGroup] < startIndex) {
-    let systemOnlyHead = true;
-    for (let position = groupStart[startGroup]; position < startIndex; position += 1) {
-      if (table.bySeq.get(surfaceNodes[position])?.type !== 'system/message') { systemOnlyHead = false; break; }
-    }
-    if (systemOnlyHead) break;
-    startIndex = groupEnd[startGroup] + 1;
-    while (startIndex < surfaceNodes.length) {
-      const type = table.bySeq.get(surfaceNodes[startIndex])?.type;
-      if (type === 'user/message' || type === 'assistant/message') break;
-      startIndex += 1;
+  if (startIndex >= surfaceNodes.length) return noPlan('no-span-start');
+  const firstGroup = groupOfPosition[startIndex];
+
+  // Earliest run of consecutive cuttable groups that lies entirely before the
+  // retention boundary and holds at least one real closed turn. Runs made only
+  // of orphan messages/pointers are not worth a surface rewrite: skip them.
+  let chosenStart = -1;
+  let chosenEnd = -1;
+  for (let index = firstGroup; index < boundary; index += 1) {
+    if (!isCuttableGroup(groups[index])) continue;
+    let runEnd = index;
+    while (runEnd + 1 < boundary && isCuttableGroup(groups[runEnd + 1])) runEnd += 1;
+    let realTurns = 0;
+    for (let cursor = index; cursor <= runEnd; cursor += 1) {
+      if (groups[cursor].kind === 'turn' && groups[cursor].turn !== 0) realTurns += 1;
     }
-    if (startIndex >= surfaceNodes.length) return null;
-    startGroup = groupOfPosition[startIndex];
+    if (realTurns > 0) { chosenStart = index; chosenEnd = runEnd; break; }
+    index = runEnd;
   }
-
-  // Cut everything older than the retention boundary, minus groups that must
-  // stay in place: the currently open/unclosed turn and groups without a turn
-  // record are never part of the span. Every other group is cut whole. This is
-  // what lets a closed aborted turn be removed together with its neighbours
-  // instead of acting as a barrier the span has to jump over.
-  let endGroup = boundary - 1;
-  let blockedAt = -1;
-  for (let index = startGroup; index <= endGroup; index += 1) {
-    if (isOpenGroup(groups[index])) { blockedAt = index; break; }
+  if (chosenStart < 0) {
+    return noPlan('blocked-prefix', {
+      firstGroup,
+      boundary,
+      blocked: groups.slice(firstGroup, boundary).map((group) => `${group.kind}:${group.turn}:${group.completed}`),
+    });
   }
-  if (blockedAt >= 0) endGroup = blockedAt - 1;
-  if (endGroup < startGroup) return null;
-  const endIndex = groupEnd[endGroup];
+  let spanStart = Math.max(startIndex, groupStart[chosenStart]);
+  const endIndex = groupEnd[chosenEnd];
+  if (endIndex < spanStart) return noPlan('empty-span', { chosenStart, chosenEnd });
 
   // A system/message node *inside* the span is a host-restart re-injection of
-  // the same prompt (the protected copy is position 0, handled above). The
-  // previous revision excluded the whole containing turn; in the real session
-  // that pinned turns 66/72/75 (≈100k tokens of ordinary dialogue carrying one
-  // injected copy each) outside every future cut, so the context could never
-  // reach the retention window. The host tolerates later system nodes inside a
-  // replacement range, so an injected copy is archived together with the old
-  // prefix it belongs to. Nodes before the span start are never touched.
-  const shadowedSeqs = surfaceNodes.slice(startIndex, endIndex + 1);
+  // the same prompt; the host tolerates it inside a replacement range and it is
+  // archived together with the old prefix (approved 1.6.6 behaviour).
+  const shadowedSeqs = surfaceNodes.slice(spanStart, endIndex + 1);
   const shadowedSet = new Set(shadowedSeqs);
   const touchedGroups = groups.filter((group) => group.seqs.some((seq) => shadowedSet.has(seq)));
-  if (touchedGroups.some((group) => isOpenGroup(group))) return null;
+  if (touchedGroups.some((group) => isCurrentTurnGroup(group))) return noPlan('current-turn-touched');
+  // No half turn: every touched turn group must be fully shadowed. The only
+  // allowed exception is a system/developer copy skipped at the head of the
+  // first group (it stays on the surface, never half-cut).
   for (const group of touchedGroups) {
     if (group.kind !== 'turn') continue;
     const missing = group.seqs.filter((seq) => !shadowedSet.has(seq));
-    if (missing.some((seq) => table.bySeq.get(seq)?.type !== 'system/message')) return null;
+    if (missing.some((seq) => !isInstructionSeq(seq))) return noPlan('split-group', { turn: group.turn });
   }
   const cutTurnGroups = touchedGroups.filter((group) => {
     if (group.kind !== 'turn' || group.turn === 0) return false;
-    const info = turnInfoOf(group);
-    return info !== undefined && info.endSeq !== null;
+    return !isCurrentTurnGroup(group);
   });
-  if (cutTurnGroups.length === 0) return null;
+  if (cutTurnGroups.length === 0) return noPlan('no-turns', { chosenStart, chosenEnd });
 
-  // Archive every original event of the cut turns, plus any checkpoint node
-  // that positionally lived inside the replaced span (a previous pointer).
+  // Archive every original event of the cut turns, plus any checkpoint node and
+  // orphan (turn===0) message that positionally lived inside the replaced span.
   const archivedSeqs = new Set();
   const archiveEvents = [];
   for (const group of cutTurnGroups) {
-    const startSeq = table.byNumber.get(group.turn)?.startSeq;
-    const endSeq = table.byNumber.get(group.turn)?.endSeq;
-    if (!Number.isInteger(startSeq) || !Number.isInteger(endSeq)) continue;
-    for (let seq = startSeq; seq <= endSeq; seq += 1) {
+    const info = table.byNumber.get(group.turn);
+    if (info === undefined || !Number.isInteger(info.startSeq)) continue;
+    const endSeq = resolvedEndSeq(group);
+    for (let seq = info.startSeq; seq <= endSeq; seq += 1) {
       const event = table.bySeq.get(seq);
       if (event === undefined || archivedSeqs.has(seq)) continue;
       archivedSeqs.add(seq);
@@ -536,13 +573,13 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
       firstSeq: seqs[0],
       lastSeq: seqs[seqs.length - 1],
       startSeq: info?.startSeq ?? seqs[0],
-      endSeq: info?.endSeq ?? seqs[seqs.length - 1],
+      endSeq: resolvedEndSeq(group),
       surfaceEvents: seqs.length,
       tokens: seqs.reduce((total, seq) => total + prices.get(seq), 0),
     };
   });
   const shadowedTokenCount = shadowedSeqs.reduce((total, seq) => total + prices.get(seq), 0);
-  if (shadowedTokenCount <= 0) return null;
+  if (shadowedTokenCount <= 0) return noPlan('zero-token');
 
   const lastTouchedIndex = groups.indexOf(touchedGroups[touchedGroups.length - 1]);
   const retainedGroups = groups.slice(lastTouchedIndex + 1);
@@ -569,7 +606,9 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
     retainedTurns,
   });
   const pointerTokens = roughPointerTokens(previewText);
-  if (shadowedTokenCount < pointerTokens + options.minCutTokens) return null;
+  if (shadowedTokenCount < pointerTokens + options.minCutTokens) {
+    return noPlan('pointer-too-large', { shadowedTokenCount, pointerTokens });
+  }
 
   return {
     start: shadowedSeqs[0],
@@ -895,6 +934,14 @@ export function createCutEngine(deps) {
       return selectCutPlan(session, this.options, measurement, {
         table,
         isCheckpointSource: isCompactCheckpointSource,
+        // "cut, or say why not": a refusal that would otherwise be silent is
+        // logged once per reason (warnOnce) so a permanently disabled hot
+        // truncate is always observable in the host log.
+        onNoPlan: (info) => {
+          const reason = String(info?.reason ?? 'unknown');
+          const detail = info?.detail === undefined || info?.detail === null ? '' : ` ${JSON.stringify(info.detail)}`;
+          this.warnOnce(`no-plan:${reason}`, `hot-truncate: 未切（${reason}）${detail}`);
+        },
       });
     }
 

package/test/hot-truncate.test.mjs

@@ -559,6 +559,119 @@ test('H30b real-session shape: head system + mid-surface injected system + abort
   assert.equal(session.surface.nodes.includes(injected.seq), false, 'injected copy left the surface');
 });
 
+// ---------------------------------------------------------------------------
+// 1.6.7 hardening: barriers must never disable hot truncate silently
+// ---------------------------------------------------------------------------
+
+/** Append a message-shaped event that belongs to no turn (no turn/start). */
+function orphanMessage(session, type, id, text) {
+  const data = type === 'assistant/message'
+    ? { message: { id, role: 'assistant', content: [{ type: 'text', text }] } }
+    : { role: type === 'system/message' ? 'system' : 'user', id, content: [{ type: 'text', text }] };
+  return session.append(type, data, { surfaceOp: 'append' });
+}
+
+test('H35 head truncated mid-turn (orphan messages before the system prompt) still cuts', async () => {
+  // Red team E1: raw log truncation drops the head turn/start, leaving orphan
+  // user/assistant surface nodes before the re-appended system prompt. 1.6.6
+  // treated the turn===0 group as open => plan null forever. Now the orphan
+  // block/head instructions are kept in place and the closed turns after them
+  // are cut (red team E1: null -> [1,2]).
+  const session = new MockSession();
+  const orphanU = orphanMessage(session, 'user/message', 'orphan-u', 'orphan-mid-turn');
+  orphanMessage(session, 'assistant/message', 'orphan-a', 'orphan answer');
+  const headSystem = orphanMessage(session, 'system/message', 'head-sys', 'HEAD-SYSTEM');
+  for (let turn = 1; turn <= 7; turn += 1) {
+    if (turn === 7) addTurn(session, turn, { open: true });
+    else addTurn(session, turn, { completed: true });
+  }
+  const dir = caseDir('archive');
+  const { engine } = engineFor({ archiveDir: dir, perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const result = await engine.compactIfNeeded(makeAgent(session), 'pressure', new AbortController().signal);
+  assert.ok(result, 'the head barrier must not disable the planner (E1 was null before)');
+  const file = fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'));
+  const parsed = readArchive(path.join(dir, file));
+  assert.deepEqual(parsed.header.cutTurns.map((entry) => entry.turn), [1, 2]);
+  assert.equal(result.shadowedSeqs.includes(headSystem.seq), false, 'head system instruction is never cut');
+  assert.equal(session.surface.nodes.includes(headSystem.seq), true, 'head system instruction stays on the surface');
+  assert.equal(session.surface.nodes.includes(orphanU.seq), true, 'orphan head block stays in place');
+});
+
+test('H36 a stray user/message between turns does not pin the prefix (red team E3)', async () => {
+  const session = new MockSession();
+  const headSystem = orphanMessage(session, 'system/message', 'head-sys', 'HEAD');
+  addTurn(session, 1, { completed: true });
+  const stray = session.append('user/message', {
+    id: 'between-turns', role: 'user', content: [{ type: 'text', text: 'between-turns' }],
+  }, { surfaceOp: 'append' });
+  for (let turn = 2; turn <= 7; turn += 1) {
+    if (turn === 7) addTurn(session, turn, { open: true });
+    else addTurn(session, turn, { completed: true });
+  }
+  const dir = caseDir('archive');
+  const { engine } = engineFor({ archiveDir: dir, perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const result = await engine.compactIfNeeded(makeAgent(session), 'pressure', new AbortController().signal);
+  assert.ok(result, 'the stray turn-0 group must not freeze the cut (E3 cut only [1] before)');
+  const file = fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'));
+  const parsed = readArchive(path.join(dir, file));
+  assert.deepEqual(parsed.header.cutTurns.map((entry) => entry.turn), [1, 2]);
+  assert.equal(result.shadowedSeqs.includes(stray.seq), true, 'the stray message is inside the cut span');
+  assert.equal(session.surface.nodes.includes(stray.seq), false, 'the stray message left the surface');
+  assert.equal(session.surface.nodes.includes(headSystem.seq), true, 'the head system instruction stays');
+  assert.equal(parsed.records.some((record) => record.seq === stray.seq), true, 'the stray message is recoverable from the archive');
+});
+
+test('H37 a mid-log turn missing turn/end does not block later cuts (red team E2)', async () => {
+  const session = new MockSession();
+  orphanMessage(session, 'system/message', 'head-sys', 'HEAD');
+  addTurn(session, 1, { completed: true });
+  const abandonedStart = session.events.length;
+  addTurn(session, 2, { open: true }); // turn/end lost by log truncation
+  const abandonedEnd = session.events.length - 1;
+  for (let turn = 3; turn <= 6; turn += 1) addTurn(session, turn, { completed: true });
+  addTurn(session, 7, { open: true }); // the real current turn
+  const currentUser = session.events.find((event) => event.type === 'user/message' && event.data.id === 'user-7');
+  const dir = caseDir('archive');
+  const { engine } = engineFor({ archiveDir: dir, perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const result = await engine.compactIfNeeded(makeAgent(session), 'pressure', new AbortController().signal);
+  assert.ok(result, 'an abandoned mid-log unclosed turn must not freeze the planner');
+  const file = fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'));
+  const parsed = readArchive(path.join(dir, file));
+  assert.deepEqual(parsed.header.cutTurns.map((entry) => entry.turn), [1, 2], 'turns before the retention window are cut');
+  const abandoned = parsed.header.cutTurns.find((entry) => entry.turn === 2);
+  assert.ok(abandoned.endSeq > abandoned.startSeq, 'abandoned turn archive range is inferred, not empty');
+  assert.equal(parsed.records.some((record) => record.turn === 2), true, 'abandoned turn events are recoverable');
+  assert.equal(session.surface.nodes.includes(currentUser.seq), true, 'the current open turn is never cut');
+  assert.equal(session.surface.nodes.some((seq) => seq >= abandonedStart && seq <= abandonedEnd), false, 'the abandoned turn left the surface');
+  assert.equal(result.shadowedSeqs.includes(currentUser.seq), false);
+});
+
+test('H38 "cut or say why": a blocked prefix logs a structured refusal instead of silence', async () => {
+  // Normal case: not enough completed turns yet.
+  const small = new MockSession();
+  addTurn(small, 1, { completed: true });
+  addTurn(small, 2, { completed: false });
+  addTurn(small, 3, { open: true });
+  const { engine, ctx } = engineFor({ archiveDir: caseDir('archive'), perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const none = await engine.compactIfNeeded(makeAgent(small), 'pressure', new AbortController().signal);
+  assert.equal(none, null);
+  assert.match(ctx.text('warn'), /未切（not-enough-turns）/);
+
+  // Blocked prefix: the only groups older than the boundary are a turn===0
+  // system zone, so there is nothing whole to cut. The reason must be visible.
+  const blocked = new MockSession();
+  orphanMessage(blocked, 'system/message', 'head-sys', 'HEAD');
+  for (let turn = 1; turn <= 5; turn += 1) {
+    if (turn === 5) addTurn(blocked, turn, { open: true });
+    else addTurn(blocked, turn, { completed: true });
+  }
+  const second = engineFor({ archiveDir: caseDir('archive'), perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const blockedResult = await second.engine.compactIfNeeded(makeAgent(blocked), 'pressure', new AbortController().signal);
+  assert.equal(blockedResult, null, 'nothing cuttable yet');
+  assert.match(second.ctx.text('warn'), /未切（blocked-prefix）/);
+  assert.match(second.ctx.text('warn'), /head-sys|blocked-prefix/);
+});
+
 test('H4 archive: atomic JSONL, exact event count, sha256, append-only', async () => {
   const dir = caseDir('archive');
   const session = buildSession(9, { openLast: false });