dsh-compact-relay 0.3.3 → 0.3.4

package/lib/dsh/model-task.js

@@ -0,0 +1,112 @@
+/**
+ * 模型任务公共装配/收尾 —— 摘要器（dsh/summarizer.js）与交接单生成
+ * （dsh/handoff-writer.js）共用的一小段「模型调用前后」逻辑。
+ *
+ * 两个任务不是同一种产物（一个压成六段摘要、一个写九段交接单，校验/重试规则
+ * 也不同），所以**不合并重试循环**；但下面四件事完全一样、以前各写一遍：
+ *   1. 前置：会话存在性 → 解析 provider/model 路由 → 窗口预算预检 → 推理档位；
+ *   2. cache 对齐参数：复用上次请求的 temperature/stop，但**绝不继承 reasoningEffort**
+ *      （2026-10-19 真机坑：会话最后请求是 max 思考，摘要沿用 max → maxTokens 被思考吃光）；
+ *   3. 单次流式调用 + finishProblem 归一（超限/工具调用/中断）；
+ *   4. 成功结果的公共元信息（provider/model/maxTokens/attempts/usage）。
+ *
+ * 只消费 dsh 层模块，不 import @deepseek-ai/*。
+ */
+import { actionError } from '../core/errors.js';
+import { assertBudget, callStream, reasoningEffortFor } from './llm-call.js';
+import { cacheControls, routeOf } from './route.js';
+import { finishProblem } from './stream.js';
+
+/**
+ * 模型调用前置：会话 → 路由 → 预算 → 推理档位。
+ *
+ * 错误码/文案由调用方给：摘要器报 'summary'、交接单报 'handoff'，保持各自入口的
+ * 用户可见文案逐字不变（这里只是把顺序收在一处）。
+ *
+ * @param {object} input
+ * @param {object} input.ctx
+ * @param {object|undefined} input.session
+ * @param {object} input.agent
+ * @param {number} [input.inputTokens] 输入 token 估算（拿不到就跳过预算预检）
+ * @param {number} input.maxTokens
+ * @param {string} input.label 给预算报错用的任务名
+ * @param {string} input.code 动作错误码
+ * @param {string} input.noSessionMessage 会话不存在时的用户可见错误文案
+ * @param {string} input.noTargetMessage 拿不到 provider/model 时的用户可见错误文案
+ * @returns {Promise<{target:{provider:string, model:string}, reasoningEffort:'off'|undefined}>}
+ */
+export async function prepareModelCall({
+  ctx,
+  session,
+  agent,
+  inputTokens,
+  maxTokens,
+  label,
+  code,
+  noSessionMessage,
+  noTargetMessage,
+}) {
+  if (session === undefined) throw actionError(code, noSessionMessage);
+
+  const target = routeOf(ctx, session, agent);
+  if (target === null) throw actionError(code, noTargetMessage);
+
+  // 架构 A2：调模型前先做窗口预算预检；超窗直接报 budget，不白等一次失败请求。
+  await assertBudget({ ctx, target, inputTokens, maxTokens, label });
+  // P2-5：只有模型目录明确支持 off 才传；非推理/不支持 off 的模型交给 adapter 默认。
+  const reasoningEffort = await reasoningEffortFor(ctx, target);
+
+  return { target, reasoningEffort };
+}
+
+/**
+ * cache 对齐参数：复用上次请求的 temperature/stop，**不要继承 reasoningEffort**。
+ *
+ * 2026-10-19 真机踩的坑：会话最后请求是 reasoningEffort=max，摘要调用沿用 max，
+ * 思考 token 把 maxTokens(4096) 吃光 → finish=max-tokens → 「摘要在输出上限处被截断」。
+ * 摘要/交接单本身都不需要长思考，是否固定 off 由模型能力决定（见 prepareModelCall）。
+ *
+ * @param {object} session
+ * @param {{provider:string, model:string}} target
+ * @returns {object}
+ */
+export function cacheAlignedControls(session, target) {
+  const { reasoningEffort: _ignored, ...controls } = cacheControls(session, target);
+  return controls;
+}
+
+/**
+ * 跑一次流式调用并把终止原因归一成可读错误（不抛；调用方决定重试/抛出）。
+ * @param {object} input
+ * @param {object} input.ctx
+ * @param {object} input.engine
+ * @param {object} input.options 传给 ctx.llm.stream 的选项（不含 signal）
+ * @param {AbortSignal} [input.signal]
+ * @param {number} [input.timeoutMs]
+ * @param {string} input.label
+ * @param {string} input.code
+ * @returns {Promise<{assembler:object, problem:Error|null}>}
+ */
+export async function callModelAttempt({ ctx, engine, options, signal, timeoutMs, label, code }) {
+  const assembler = await callStream({ ctx, engine, options, signal, timeoutMs, label });
+  return { assembler, problem: finishProblem(assembler, { code, label }) };
+}
+
+/**
+ * 成功结果的公共元信息（两个任务返回结构里逐字相同的那一段）。
+ * @param {object} input
+ * @param {object} input.assembler
+ * @param {{provider:string, model:string}} input.options
+ * @param {number} input.maxTokens
+ * @param {number} input.attempt
+ * @returns {{provider:string, model:string, maxTokens:number, attempts:number, usage?:object}}
+ */
+export function modelAttemptResult({ assembler, options, maxTokens, attempt }) {
+  return {
+    provider: options.provider,
+    model: options.model,
+    maxTokens,
+    attempts: attempt,
+    ...(assembler.usage === undefined ? {} : { usage: assembler.usage }),
+  };
+}

package/lib/dsh/relay.js

@@ -2,7 +2,7 @@
  * 接力链的读写接缝（A5）。
  *
  * 读：从会话日志尾部找最近一条 `plugin:compact-relay/relay`；
- * 写：engine.appendPluginRecord（和 stage/pin 同一个宿主 API）。
+ * 写：engine.appendPluginRecord（和压缩判断记录/pin 同一个宿主 API）。
  * 记录缺失/损坏一律当作没有（旧会话兼容），不阻断交接。
  */
 import { RELAY_RECORD_TYPE } from '../core/relay.js';

package/lib/dsh/session-view.js

@@ -2,10 +2,11 @@
  * 只读的 session 视图 —— 把 Session 的访问面收在一处。
  *
  * 事务层（compact-transaction）不直接翻 session 内部结构，
- * 都从这里拿；M2 的 checkpoint 定位、M4 的阶段标记也在这里。
+ * 都从这里拿；M2 的 checkpoint 定位、压缩判断记录也在这里。
  */
 import { latestCompressHint } from '../core/compress-hint.js';
 import { latestPinnedSeqs } from '../core/pins.js';
+import { scanCompactionLog } from './compaction-pair.js';
 
 /** @returns {number[]} 当前 surface 的 event seq（升序） */
 export function surfaceSeqs(session) {
@@ -47,21 +48,8 @@ export function firstCompactableIdx(session) {
  * 没有 compactionId 的旧日志（或外部夹具）按旧口径计数，保证兼容。
  */
 export function countSummaries(session) {
-  const log = sessionLog(session);
-  const summaries = [];
-  const ends = new Map();
-  const replacedSeqs = new Set();
-  for (const event of log) {
-    if (event === null || event === undefined) continue;
-    if (event.type === 'compaction/summary') {
-      summaries.push(event);
-    } else if (event.type === 'compaction/end') {
-      const id = event.data?.compactionId;
-      if (typeof id === 'string') ends.set(id, event.data);
-    } else if (event.type === 'user/message' && Array.isArray(event.sourceEventSeqs)) {
-      for (const seq of event.sourceEventSeqs) replacedSeqs.add(seq);
-    }
-  }
+  // 配对扫描（summary/end/replace）与 dsh/compaction-log 共用，口径见 compaction-pair.js。
+  const { summaries, ends, replaceByCoveredSeq } = scanCompactionLog(sessionLog(session));
   let count = 0;
   for (const summary of summaries) {
     const id = summary.data?.compactionId;
@@ -71,7 +59,7 @@ export function countSummaries(session) {
     }
     const end = ends.get(id);
     if (end === undefined || end.error !== undefined) continue;
-    if (!replacedSeqs.has(summary.seq)) continue;
+    if (!replaceByCoveredSeq.has(summary.seq)) continue;
     count += 1;
   }
   return count;

package/lib/dsh/settings-file.js

@@ -7,6 +7,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { defaultDshHome } from '../core/config-schema.js';
+import { isPlainObject } from '../core/object.js';
 
 /** 设置文件名（放在 DSH_HOME 下）。 */
 export const SETTINGS_FILE = 'compact-relay.json';
@@ -19,10 +20,6 @@ export function defaultSettingsPath() {
   return path.join(defaultDshHome(), SETTINGS_FILE);
 }
 
-function isPlainObject(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
 /**
  * 把设置文件读成「用户覆盖层」。
  *

package/lib/dsh/state-hub.js

@@ -5,13 +5,18 @@
  * 收到后对有订阅者的会话做一次去抖刷新（复用 readState），
  * 通过 SSE 推给浏览器半；浏览器断线会自动退回轮询（见 lib/client.js）。
  *
- * 只推「当前有订阅者的会话」，不给所有会话做无谓测量。
+ * 0.3.4（BUG-010）：除了 SSE 推送，这里还无条件维护一份「最新状态」缓存。
+ * 模型判断「这里适合压缩」需要当前容量，而 `ctx.systemPrompt.context` 的
+ * text 回调必须是**同步**的 —— 不能在那里 await readState。所以每条
+ * session/event 到达后（150ms 防抖）都算一次状态，把提示需要的最小投影
+ * `{ratio, window, compressHint}` 存进 `latest`，供 systemPrompt 同步读取。
+ * 会话数量很少，这点内存/计算可忽略；没有订阅者时只是不写 SSE 帧。
  *
  * A9：dsh 层不再反向 import actions/state —— readState 由装配层注入，
  * 这样 state-hub 可以脱离动作层单测，依赖方向回到 dsh → core。
  */
 
-/** 事件去抖：一轮 turn 里事件很密，攒 150ms 只推一次。 */
+/** 事件去抖：一轮 turn 里事件很密，攒 150ms 只算/推一次。 */
 const PUSH_DEBOUNCE_MS = 150;
 
 /** SSE 心跳：防止中间层把空闲连接掐掉。 */
@@ -44,6 +49,21 @@ export function createStateHub({ readState }) {
   /** @type {Map<string, ReturnType<typeof setTimeout>>} 未就绪时的退避重试 */
   const retryTimers = new Map();
 
+  /**
+   * 最新状态缓存（systemPrompt 同步读）：sessionId → {ratio, window, compressHint}。
+   * 只存提示需要的最小投影，不存整个 state（颜色/选段等没人从缓存读）。
+   * @type {Map<string, {ratio:number, window:number, compressHint:object|null}>}
+   */
+  const latest = new Map();
+
+  /**
+   * 缓存对应的 readState.revision（单调递增）。缓存写入有竞态：防抖/重试/SSE 并发时，
+   * 先发出的慢读可能后完成并把新值覆盖成旧值。用 revision 做版本守卫：
+   * 只有 `state.revision >= 已缓存 revision` 才允许覆盖。
+   * @type {Map<string, number>}
+   */
+  const latestRevision = new Map();
+
   const cancelRetry = (sessionId) => {
     const timer = retryTimers.get(sessionId);
     if (timer !== undefined) {
@@ -53,26 +73,71 @@ export function createStateHub({ readState }) {
   };
 
   /**
-   * 推一次状态；返回是否「就绪」（state.sessionId 非空）。
+   * 把 state 投影进缓存。
+   *
+   * 两条守卫（审计 2026-10-24 修正）：
+   *  1. `state.sessionId === sessionId` 才写 —— 防止 pickAgent/缓存键对错会话；
+   *  2. `state.revision >= 已缓存 revision` 才覆盖 —— 防乱序完成（慢读后到）把新值写回旧值。
+   *
+   * 缓存键用**事件里的 session.id**（不是 agent.id，两者不同）；会话被卸载/还没加载
+   * （state.sessionId 为空）时清掉旧缓存，避免动态提示读到已经不存在的会话。
+   * @param {string} sessionId 事件里的会话 id（缓存键）
+   * @param {object} state readState 的结果
+   */
+  const remember = (sessionId, state) => {
+    if (state === null || typeof state !== 'object') return;
+    if (typeof state.sessionId !== 'string' || state.sessionId.length === 0) {
+      latest.delete(sessionId);
+      latestRevision.delete(sessionId);
+      return;
+    }
+    // 只缓存本会话的状态：sessionId 对不上时宁可不写（保留旧缓存也比串会话安全）。
+    if (state.sessionId !== sessionId) return;
+    if (!Number.isFinite(state.ratio) || !Number.isFinite(state.window) || state.window <= 0) return;
+    const nextRevision = Number.isFinite(state.revision) ? state.revision : null;
+    const cachedRevision = latestRevision.get(sessionId);
+    if (
+      nextRevision !== null &&
+      Number.isFinite(cachedRevision) &&
+      nextRevision < cachedRevision
+    ) {
+      return; // 乱序完成的旧结果：不覆盖新缓存
+    }
+    latest.set(sessionId, {
+      ratio: state.ratio,
+      window: state.window,
+      compressHint:
+        state.compressHint !== null && typeof state.compressHint === 'object' ? state.compressHint : null,
+    });
+    if (nextRevision !== null) latestRevision.set(sessionId, nextRevision);
+  };
+
+  /**
+   * 算一次状态：更新缓存 + 推给订阅者。返回是否「就绪」（state.sessionId 非空）。
+   * 没有订阅者也照样算 —— 缓存是 systemPrompt 动态提示的唯一数据源。
    * @returns {Promise<boolean>}
    */
   const pushNow = async (sessionId) => {
-    const listeners = clients.get(sessionId);
-    if (listeners === undefined || listeners.size === 0) return true;
     let state;
     try {
       state = await readState(sessionId);
     } catch {
-      return false; // 测量失败就先不推，下一次事件/重试再试
+      return false; // 测量失败就先不推/不缓存，下一次事件/重试再试
     }
-    const frame = `data: ${JSON.stringify(state)}\n\n`;
-    for (const res of [...listeners]) {
-      if (!writeFrame(res, frame)) {
-        listeners.delete(res);
+    if (state === null || typeof state !== 'object') return false;
+    remember(sessionId, state);
+
+    const listeners = clients.get(sessionId);
+    if (listeners !== undefined && listeners.size > 0) {
+      const frame = `data: ${JSON.stringify(state)}\n\n`;
+      for (const res of [...listeners]) {
+        if (!writeFrame(res, frame)) {
+          listeners.delete(res);
+        }
       }
+      if (listeners.size === 0) clients.delete(sessionId);
     }
-    if (listeners.size === 0) clients.delete(sessionId);
-    return state !== null && typeof state === 'object' && typeof state.sessionId === 'string';
+    return typeof state.sessionId === 'string';
   };
 
   /**
@@ -100,11 +165,21 @@ export function createStateHub({ readState }) {
       timers.delete(sessionId);
       void pushNow(sessionId);
     }, PUSH_DEBOUNCE_MS);
-    // 别让推送定时器拖住进程退出
+    // 别让推送/缓存定时器拖住进程退出
     if (typeof timer.unref === 'function') timer.unref();
     timers.set(sessionId, timer);
   };
 
+  /**
+   * 同步读最新状态投影（systemPrompt.context 的 text 回调只能同步）。
+   * @param {string} sessionId
+   * @returns {{ratio:number, window:number, compressHint:object|null}|undefined}
+   */
+  const latestState = (sessionId) => {
+    if (typeof sessionId !== 'string' || sessionId.length === 0) return undefined;
+    return latest.get(sessionId);
+  };
+
   /**
    * SSE 入口。`GET /api/compact-relay-stream?sessionId=...`
    * @param {object} req
@@ -159,17 +234,16 @@ export function createStateHub({ readState }) {
   };
 
   /**
-   * 订阅 host 的 session/event：只对「有人订阅的会话」安排推送。
+   * 订阅 host 的 session/event：不管有没有 SSE 订阅者，都要更新状态缓存
+   * （systemPrompt 提示读它）；有订阅者的会话顺带推帧。
    * @param {object} session
    * @param {object} _event
    */
   const onSessionEvent = (session, _event) => {
     const sessionId = session !== null && typeof session === 'object' ? session.id : undefined;
     if (typeof sessionId !== 'string' || sessionId.length === 0) return;
-    if (clients.has(sessionId)) {
-      cancelRetry(sessionId);
-      schedule(sessionId);
-    }
+    cancelRetry(sessionId);
+    schedule(sessionId);
   };
 
   /** 设置保存后立刻让所有订阅者重读一次状态（颜色/阈值马上变）。 */
@@ -195,9 +269,11 @@ export function createStateHub({ readState }) {
       }
     }
     clients.clear();
+    latest.clear();
+    latestRevision.clear();
   };
 
-  return { serve, onSessionEvent, refreshAll, close, noop };
+  return { serve, onSessionEvent, refreshAll, close, latestState, noop };
 }
 
 export default createStateHub;

package/lib/dsh/summarizer.js

@@ -12,9 +12,7 @@ import { actionError } from '../core/errors.js';
 import { rangeNotice, recoveryHint } from '../core/prompts.js';
 import { REQUIRED_SECTIONS, describeProblems, validateSummary } from '../core/validate-summary.js';
 import { buildPrefix } from './prefix.js';
-import { assertBudget, callStream, reasoningEffortFor } from './llm-call.js';
-import { cacheControls, routeOf } from './route.js';
-import { finishProblem as streamProblem } from './stream.js';
+import { cacheAlignedControls, callModelAttempt, modelAttemptResult, prepareModelCall } from './model-task.js';
 
 /** 最多尝试次数（首次 + 1 次带 recovery 提示的重试）。 */
 const MAX_ATTEMPTS = 2;
@@ -59,15 +57,17 @@ export async function summarize({
   requiredSections = REQUIRED_SECTIONS,
 }) {
   const session = agent?.session;
-  if (session === undefined) throw actionError('summary', '会话不存在，无法生成摘要');
-
-  const target = routeOf(ctx, session, agent);
-  if (target === null) throw actionError('summary', '没有可用的 provider/model，无法发起压缩');
-
-  // 架构 A2：调模型前先做窗口预算预检；超窗直接报 budget，不白等一次失败请求。
-  await assertBudget({ ctx, target, inputTokens, maxTokens, label: '压缩摘要' });
-  // P2-5：只有模型目录明确支持 off 才传；非推理/不支持 off 的模型交给 adapter 默认。
-  const reasoningEffort = await reasoningEffortFor(ctx, target);
+  const { target, reasoningEffort } = await prepareModelCall({
+    ctx,
+    session,
+    agent,
+    inputTokens,
+    maxTokens,
+    label: '压缩摘要',
+    code: 'summary',
+    noSessionMessage: '会话不存在，无法生成摘要',
+    noTargetMessage: '没有可用的 provider/model，无法发起压缩',
+  });
 
   const regionCount = regionMessageCount(session, shadowedSeqs);
   if (regionCount === 0) throw actionError('summary', '没有可摘要的消息');
@@ -76,11 +76,7 @@ export async function summarize({
   if (prefix.length === 0) throw actionError('summary', '回放前缀为空');
 
   const header = session.requestHeader?.();
-  // cache 对齐只保留 temperature/stop；**不要继承 reasoningEffort**。
-  // 2026-10-19 真机踩的坑：会话最后请求是 reasoningEffort=max，摘要调用沿用 max，
-  // 思考 token 把 maxTokens(4096) 吃光 → finish=max-tokens → 「摘要在输出上限处被截断，未提交」。
-  // 压缩摘要本身不需要长思考，固定 off，稳且便宜。
-  const { reasoningEffort: _ignored, ...controls } = cacheControls(session, target);
+  const controls = cacheAlignedControls(session, target);
   const baseInstruction = `${rangeNotice(regionCount)}\n\n${instruction}`;
 
   let lastProblems = [];
@@ -101,16 +97,15 @@ export async function summarize({
       purpose: 'compaction',
     };
 
-    const assembler = await callStream({
+    const { assembler, problem } = await callModelAttempt({
       ctx,
       engine,
       options,
       signal,
       timeoutMs,
       label: '压缩摘要',
+      code: 'summary',
     });
-
-    const problem = streamProblem(assembler, { code: 'summary', label: '压缩摘要' });
     if (problem !== null) {
       // 输出被截断 → 还有尝试机会时，带着「写短一点」的提示重试一次（真机 2026-10-19 踩过）。
       if (assembler.finish?.kind === 'max-tokens' && attempt < MAX_ATTEMPTS) {
@@ -130,11 +125,7 @@ export async function summarize({
     if (validation.ok) {
       return {
         summary: validation.summary,
-        provider: options.provider,
-        model: options.model,
-        maxTokens,
-        attempts: attempt,
-        ...(assembler.usage === undefined ? {} : { usage: assembler.usage }),
+        ...modelAttemptResult({ assembler, options, maxTokens, attempt }),
       };
     }
     lastProblems = validation.problems;

package/lib/index.js

@@ -9,6 +9,7 @@ import { readState } from './actions/state.js';
 import { createLock } from './actions/lock.js';
 import { registerCommands } from './adapters/commands.js';
 import { registerHttp } from './adapters/http.js';
+import { registerCompressCue } from './adapters/prompt.js';
 import { registerTool } from './adapters/tool.js';
 import { createSettingsStore } from './actions/settings.js';
 import engine from './dsh/engine.js';
@@ -16,11 +17,20 @@ import { createStateHub } from './dsh/state-hub.js';
 
 export const name = 'compact-relay';
 
-/** 需要的 DSH 服务；webServer 用 ctx.inject 单独要，headless 环境也能加载。
- *  注意：`compaction` 是 **agent 作用域**的服务（挂在 preset 的隔离组里），
- *  根上下文拿不到——所以不放进 inject，改用 agent.ctx.compaction 动态取。
+/**
+ * 需要的 DSH 服务；webServer 用 ctx.inject 单独要，headless 环境也能加载。
+ *
+ * 注意：`compaction` 是 **agent 作用域**的服务（挂在 preset 的隔离组里），
+ * 根上下文拿不到——所以不放进 inject，改用 agent.ctx.compaction 动态取。
+ *
+ * `systemPrompt`（0.3.4）：它是 DSH 0.2.x 的核心根服务（点灯/命令等插件都依赖它），
+ * 这里和 memory 插件一样放根 `inject`。**该服务缺失时本插件会 pending、apply 不会执行**
+ * ——这是 cordis inject 的语义，不是 cue 特有的降级；apply 里的
+ * `typeof ctx.systemPrompt?.context === 'function'` 守卫针对的是「服务在、但形状不对/
+ * 被裁剪」的异常环境。cue 只是增强项，但它的依赖声明与其它入口同级，没有为它单独做
+ * 可选注入（避免引入 scoping 风险）。报告「兼容性」一节记录了这个前置。
  */
-export const inject = ['commands', 'agents', 'tokenMeter', 'llm', 'sessions', 'tools'];
+export const inject = ['commands', 'agents', 'tokenMeter', 'llm', 'sessions', 'tools', 'systemPrompt'];
 
 /**
  * @param {object} ctx
@@ -53,15 +63,27 @@ export function apply(ctx, config) {
   });
   ctx.effect(() => () => settings.close(), 'compact-relay: settings store');
 
-  // M5：状态推送中枢（SSE）。订阅会话事件，有人订阅才推。
+  // M5：状态推送中枢（SSE）。订阅会话事件；0.3.4 起无论有没有订阅者都维护
+  // 一份最新状态缓存，供下面的 systemPrompt 动态提示同步读取。
   // A9：readState 由这里注入，dsh 层不反向依赖 actions 层。
   const hub = createStateHub({ readState: (sessionId) => readState(deps, { sessionId }) });
   deps.hub = hub;
   ctx.on('session/event', (session, event) => hub.onSessionEvent(session, event));
   ctx.effect(() => () => hub.close(), 'compact-relay: state hub');
 
+  // 0.3.4（BUG-010）：给模型一条「当前在可压缩区间」的动态 system-prompt 提示，
+  // 让「这里适合压缩」从不可判断变成可判断。
+  // 注意：systemPrompt 在根 inject 里 —— 宿主缺该服务时插件会 pending、apply 根本不会跑
+  // （cordis inject 语义，详见文件顶部 inject 注释）；下面的 typeof 守卫只覆盖
+  // 「服务在、但形状不对/被裁剪」的异常环境，此时跳过 cue（其它入口不受影响）。
+  if (typeof ctx.systemPrompt?.context === 'function') {
+    ctx.effect(() => registerCompressCue(ctx, deps, hub), 'compact-relay: compress cue');
+  } else {
+    log?.warn?.('宿主 systemPrompt 服务缺少 context()（形状异常），跳过「可压缩区间」动态提示；其它入口不受影响。');
+  }
+
   registerCommands(ctx, deps);
-  // 0.3.1：模型的「这里适合压缩」判断（环上的断点1）。
+  // 0.3.1：模型判断「这里适合压缩」（环上断点1）；0.3.4 起工具名改为 mark_compress_point。
   registerTool(ctx, deps);
   // 2026-10-20 安全修复：HTTP 端点必须和宿主 /api 用同一个 connection 服务做鉴权
   // （Host/Origin fence + 浏览器 token）。只 inject webServer 时拿不到 connection，

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-compact-relay",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "DeepSeek Harness 上下文指示器插件：提供容量监控、压缩预览与确认、九段式交接单生成及消息锁定功能。 · Context indicator for DSH: preview-then-confirm compaction, 9-section session handoff, and pinned messages.",
   "type": "module",
   "main": "lib/index.js",
@@ -53,7 +53,7 @@
     "node": ">=22"
   },
   "scripts": {
-    "test": "node scripts/build-client.mjs --check && node --check lib/client.js && node test/smoke.mjs && node test/handoff.mjs && node test/plugin-load.mjs && node test/contract.mjs && node test/compact-log.mjs",
+    "test": "node scripts/build-client.mjs --check && node --check lib/client.js && node test/smoke.mjs && node test/handoff.mjs && node test/plugin-load.mjs && node test/contract.mjs && node test/compact-log.mjs && node test/compress-cue.mjs && node test/markdown-lite.mjs",
     "test:e2e": "node test/e2e/smoke.mjs",
     "test:e2e:settings": "node test/e2e/settings-ui.mjs",
     "test:e2e:compact": "node test/e2e/real-compact.mjs"

package/lib/actions/stage.js

@@ -1,36 +0,0 @@
-/**
- * 标记进度（M4，内部代号「阶段标记」）—— 把「这个阶段完成了」写进会话日志。
- *
- * 只写一条 plugin record：不进模型上下文、不影响 token，压缩/交接都不会碰它。
- * 指示灯读到最新一条后外环变阶段色（默认蓝）；下一次压缩/交接（产生新 checkpoint）之后自动失效。
- */
-import { actionError } from '../core/errors.js';
-import { STAGE_RECORD_TYPE, normalizeStageLabel } from '../core/stage.js';
-import { measurePressure } from '../dsh/pressure.js';
-
-/**
- * @param {{engine:object, ctx?:object, cfg?:object}} deps
- * @param {{agent:object, label?:string}} input
- * @returns {Promise<{label:string, at:number, seq:number, ratio:number|null}>}
- */
-export async function markStage(deps, { agent, label } = {}) {
-  const session = agent?.session;
-  if (session === null || session === undefined) throw actionError('stage', '没有活动会话');
-  const normalized = normalizeStageLabel(label);
-  const at = Date.now();
-  // 0.3.1：记下标记那一刻的容量比例，指示灯才能在环上标出「标记位置」。
-  // 测不到（会话刚开 / tokenMeter 不可用）就记 null，环上退化到当前比例。
-  const measured = await measurePressure(deps.ctx, agent, {
-    windowFallback: deps.cfg?.contextWindowFallback ?? 1_000_000,
-  }).catch(() => null);
-  const ratio =
-    measured !== null && typeof measured === 'object' && typeof measured.ratio === 'number' && Number.isFinite(measured.ratio)
-      ? Math.max(0, Math.min(1, measured.ratio))
-      : null;
-  const seq = deps.engine.appendPluginRecord(session, STAGE_RECORD_TYPE, {
-    label: normalized,
-    at,
-    ...(ratio === null ? {} : { ratio }),
-  });
-  return { label: normalized, at, seq, ratio };
-}

package/lib/core/stage.js

@@ -1,96 +0,0 @@
-/**
- * 标记进度（M4，内部代号「阶段标记」）—— 纯数据与纯判定，不依赖 DSH。
- *
- * 模型调 `mark_stage` 工具时，往会话日志追加一条 plugin record：
- *   plugin:compact-relay/stage   data: { label, at, ratio }
- *
- *   ratio 是标记那一刻的容量比例（0–1），用来在指示灯的环上标出「标记位置」；
- *   旧记录没有这个字段时按 null 处理（环上退化成标记当前比例）。
- *
- * plugin record 是 DSH 0.2 的「插件私有事件」：`ignorable`、不进模型可见 surface、
- * 跟着会话落盘/分叉/迁移。所以「阶段完成」不会被压缩掉，重启后也还在。
- */
-
-/** 记录类型（DSH 语法：`plugin:` + 小写段；只认精确匹配，不收别的插件）。 */
-export const STAGE_RECORD_TYPE = 'plugin:compact-relay/stage';
-
-/** 没给 label 时的默认阶段名。 */
-export const STAGE_DEFAULT_LABEL = '本阶段完成';
-
-/** label 长度上限（超了截断，避免把整段话塞进指示灯标题）。 */
-export const STAGE_LABEL_MAX = 80;
-
-/**
- * 规范化阶段名：去首尾空白、折叠连续空白、超长截断；空值回落到默认名。
- * @param {unknown} raw
- * @returns {string}
- */
-export function normalizeStageLabel(raw) {
-  if (typeof raw !== 'string') return STAGE_DEFAULT_LABEL;
-  const text = raw.replace(/\s+/gu, ' ').trim();
-  if (text.length === 0) return STAGE_DEFAULT_LABEL;
-  // 用码点截断，别切裂 emoji 的 surrogate pair（截出孤立代理会显示成 �）。
-  const chars = Array.from(text);
-  return chars.length > STAGE_LABEL_MAX ? `${chars.slice(0, STAGE_LABEL_MAX - 1).join('')}…` : text;
-}
-
-/**
- * 该事件是不是本插件的阶段记录。
- * plugin record 的判定 = `ignorable === true` + 类型精确匹配（我们只写自己的类型）。
- * @param {unknown} event
- * @returns {boolean}
- */
-export function isStageRecordEvent(event) {
-  return event !== null && typeof event === 'object' && event.ignorable === true && event.type === STAGE_RECORD_TYPE;
-}
-
-/**
- * 从会话事件流里取最近的 N 条阶段标记（最新的在前）。
- *
- * 0.3.1：从「只取最新一条」升级为「保留最近几个」——指示灯环上可以同时画出多个
- * 阶段块（最新的最亮，旧的半透明）。`limit` 由配置 `stage.maxMarks` 决定（1–10）。
- *
- * @param {object[]} events
- * @param {number} [limit=3]
- * @returns {{label:string, at:number, seq:number, ratio:number|null}[]}
- */
-export function latestStageMarks(events, limit = 3) {
-  if (!Array.isArray(events)) return [];
-  const cap = Number.isInteger(limit) && limit > 0 ? Math.min(limit, 20) : 3;
-  const marks = [];
-  for (const event of events) {
-    if (!isStageRecordEvent(event)) continue;
-    const data = event.data;
-    if (data === null || typeof data !== 'object') continue;
-    const at = typeof data.at === 'number' && Number.isFinite(data.at) ? data.at : 0;
-    const ratio =
-      typeof data.ratio === 'number' && Number.isFinite(data.ratio)
-        ? Math.max(0, Math.min(1, data.ratio))
-        : null;
-    marks.push({ label: normalizeStageLabel(data.label), at, seq: event.seq, ratio });
-  }
-  return marks.slice(-cap).reverse();
-}
-
-/**
- * 从会话事件流里取最近一条阶段标记；没有或数据不合法返回 null。
- * @param {object[]} events
- * @returns {{label:string, at:number, seq:number, ratio:number|null}|null}
- */
-export function latestStageMark(events) {
-  return latestStageMarks(events, 1)[0] ?? null;
-}
-
-/**
- * 标记进度是否「仍然新鲜」：要比最后一次压缩 checkpoint 新才算数。
- *
- * 这样压缩/交接之后圆环自动恢复常态，不用额外写「清除」记录。
- * @param {{seq:number}|null} mark
- * @param {number|undefined} checkpointSeq 最后一次 checkpoint 消息的 event seq
- * @returns {boolean}
- */
-export function stageIsActive(mark, checkpointSeq) {
-  if (mark === null || mark === undefined) return false;
-  if (!Number.isInteger(checkpointSeq)) return true;
-  return mark.seq > checkpointSeq;
-}